Studio for Multiprocessing4Xi, Scope4Xi & DragonXi [Rel 7.21] [Win8.1/Win7.1/Linux] [Py3.3] [OpenCLv1.2][Plone4.1] [URI][April 27,2015 Ω 10:26 PM]

ΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞ

~ Macros Δ
~ Parsing Δ
~ Time Δ
~ Verbalize Δ
~ Symbolize2verb4xi Δ
~ Walk Δ
~ Zap Δ
~ Fetching Scope4Xi Programs Δ
~ Building Scope Programs Δ

~ Fetch2url4scope Δ
~ To-be-solved Δ
~ Nouns Δ
~ Version Δ
~ Finding Δ
~ To-be-done Δ
~ Symbolize2actor Δ
~ Print4Xi Δ
~ Dragonizing Δ

~ Generating Image Programs for Devices Δ
~ Program Macros Δ
~ Developer Macros Δ
~ Tag Profile Codes Δ
~ Verbs and Scoping Δ
~ Profiles for Kyeboard Δ
~ Utility Tester Profile Δ
~ Multicore CPU sensing Δ
~ Commander Profile Δ

~ Module Tester Profile Δ
~ Scoped Sense-, Ace- and Reason-XML-files Δ
~ Zapped Programs Δ
~ Deployment to Scope4xi Δ
ξ All modules dragonized Δ
ξ WEB4Xi Δ
~ Ctypes and Multiprocessing
~ Proxy Objects in Multiprocessing
~ Benchmarks in Multiprocessing

~ Server with Pool Workers
~ Calculating with Pool of Workers
~ Locks and Semaphores
ξ Server with Pool Workers
ξ Constants4Xi Δ Δ Δ
ξ Managers
~ _init__ (Manager4Xi) Δ Δ (package missing)
ξ Multicore CPU Test Δ Δ Δ
ξ Locks and Semaphores Test Δ

ξ Process Reference Δ
ξ Pool of workers with Pool4Xi Δ
ξ Manager with Manager4Xi Δ
ξ Benchmarks Δ
ξ Proxy Objects
ξ Customized Manager and Proxies Δ
ξ Calculating with Pool of Workers Δ
ξ Test All Methods4Xi
ξ Connection dummy DRAGONIZED

ξ Synchronization with Lock4Xi Δ
ξ Pipes with Process4Xi, Queue4Xi and Pipe4Xi Δ
ξ Queues with Process4Xi and Queue4Xi Δ
ξ Ctypes with ArrayFunction4Xi Δ
ξ Connection module Δ Δ Δ
ξ Synchronization module Δ Δ Δ
ξ Process Δ Δ Δ
ξ Managers Δ Δ Δ
ξ Forking Δ Δ Δ

ξ Heap Δ Δ Δ
ξ Pool Δ Δ Δ
ξ Queue Δ Δ Δ
ξ Reduction Δ Δ Δ
ξ Sharedctypes Δ Δ Δ
ξ Util Δ Δ Δ
ξ BLOG Δ

ΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞ

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~ Macros

Macros
ξ »macro4xi.py
ξ creates macros for all command messages to be embedded in dragonized programs

~[Σ] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~ Parsing

Scope4Xi

ξ »parse2scope4xi.py
ξ parses all scope4xi programs

Multiprocessing4Xi

ξ »parse4xi.py
ξ parses all multiprocessing4xi programs

Studio4Xi

ξ »parsestudio4xi
ξ parses all studio4xi programs

select: ~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~ Time

Time
ξ »time4xi.py
ξ provides time services

select: ~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~ Verbalize

Verbalize
ξ »verbalize4xi.py
ξ reads all verb2*4xi.py in multiprocessing4xi and creates XML-file about all verbs in the system

select: ~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~ Symbolize2verb4xi

Symbolize2verb4xi
ξ »symbolize2verb4xi
ξ reads all programs in multiprocessing4xi and builds index for verb symbols in the system

select: ~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~ Walk

>Walk
ξ »walk4py.py
ξ walks directories

select: ~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~ Zap

Zap
ξ »zap2module4xi.py
ξ provides module dictionary for zapping

select: ~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~ Fetching Scope Programs

Fetching Scope Programs
ξ »fetch2scope4xi.py
ξ »version4xi.py
ξ fetch2scope4xi.py fetches defined modules from scopexi using settings defined in version4xi.py

Output
ξ »apu2image4xi.py
ξ »apu2image4xi5test.py
ξ »apu3image4xi.py
ξ »apu3image4xi5test.py
ξ 2D and 3D image processing modules of Scope4Xi fetched to L:\temp\py\ for processing
ξ this is not done in the same way as generate2image4scope, which is muche better way to do it!
ξ however, once dragon2image4xi.py is ok and generates ok for all devices - including module apu2image4xi.py for apu device - this process is not necessary!

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~ Building Scope Programs

Building Scope Programs
ξ »build2scope4xi.py
ξ builds defined exe files in scopexi
ξ due to bug in Python marshal operation fails - one must wait until the guys get this bug fixed !

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~ Fetch2url4scope

Fetch2url4scope
ξ »fetch2url4scope.py
ξ should fetch resources identified by URI(s)/URL(s)
ξ due to Python 3.3. aythorization fails - to be fixed
ξ programmed to test fetching Python source files from Web portal for create2kernel4apu.py in scope4xi

select: ~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~ ICEFELLOW

ICEFELLOW

FTP of icefellow at WebFaction Server in PC for www.dragonxi.com

ξ »find2txt4icefellow.py
ξ finds for example errors in all text files in FTP folder icefellow to examine possible errors during buildout process in server
ξ default is dragon64

ξ »find2py4icefellow.py
ξ finds for example text patterns in all Python programs in FTP folder icefellow to examine which program may display errors during buildout process in server
ξ default is dragon64

ξ »find2log4icefellow.py
ξ finds for example text patterns in all log files produces by buildout process in server
ξ default is icefellow

ξ »version4xi.py
ξ knowledgebase for DragonXi paths

select: ~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~ Nouns

Nouns

ξ »test_noun4xi.py
ξ »noun4xi.py
ξ »noun2cluster4xi.py
ξ defined colors to all clusters
ξ »(029) Scoped sense-, ace- and reason-XML-files

select: ~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~ Version

Version

ξ »version4xi.py
ξ essential module to import - makes programs more platform independent while allowing import without having to know where modules are located!

select: ~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~ Finding

Scope4Xi

ξ »find2py4scope.py
ξ finds eight (8) text string in programs of Scope4Xi

ξ »find2text4scope.py
ξ finds eight (8) text string in text files of Scope4Xi

ξ »find2xml4scope.py
ξ finds eight (8) text string in XML files of Scope4Xi

Multiprocessing4Xi

ξ »find4py.py
ξ finds required string patterns in Multiprocessing4xi python programs

ξ »find4share.py
ξ finds shared variables and their usage in Python programs

ξ »find4txt.py
ξ finds eight (8) text string in files

ξ »find4xi.py
ξ finds text patterns in text files

ξ »find4zap.py
ξ finds unresolved actors in zap-modules

Boost

ξ »find4boost.py
ξ finds eight (8) text string in C++ programs of Boost
ξ freezed Boost

PyOpenCL

ξ »find4cl.py
ξ finds eight (8) text string in PyOpenCL programs
ξ freezed PyOpenCL

select: ~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~ TO-BE-DONE

TO-BE-DONE

Check Hypertext Links

ξ check in all three index files hyperlinks to other files!

Statistics

ξ module/function/class quantity/size with mean/std ...

Embed trace into programs

ξ create software which embeds trace into multiprocessing4xi programs
ξ use test output text file as input and according to its trace settings add trace into programs
ξ automated trace embedding saves time to manually add trace

[] Parsing
ξ »parse4xi.py
ξ produce results also to XML-file

Add sleep times and tune timeouts in the system Δ
»sleep4xi.py
»timeout4xi.py

Upgrade the system more re-entrant
ξ use function/method variables
ξ use class variables for shared one
ξ use class registry for those needing re-entrancy but which should not add anything extra to an object

Move to use class variables for constants Δ
»Process4Xi

Create messages using pipes and queus between different processes
ξ check whether managers are necessary

Instead of using default family with get_default_family4xi-function set up once the system family and use it
ξ otherwise the software works ONLY for the default family !

Create test_all4xi.py to run all tests in one test module
ξ consider control panel type of GUI
ξ direct each test output(if it generates) to XML-file

Add ack4manoeuvres and nack4manoeuvres statistics to critical classes for sensing

DEALER
ξ request from dealer schemas ie instead of if OS is x or Windows, give me this service such as socket or pipe !
ξ email sending of XML results !
ξ DATABASE using perhaps Plone ODB !

None passing and processing in the whole system
ξ for example all __init__ methods
ξ check all while because trace in while-loops must be limited

Add sleep where you have to receive Δ
ξ for example adddress might become none !!!

Miscellaneous

ξ program YourDragon4Xi to initialize and start your dragon !

ξ check registering to ForkingPickler4Xi at module level conditionally as is reduce_pipe_connection4xi.py!

ξ complete all sense methods and supply for try as in queue4xi.py and use as test_math_mp_xi4.py - very useful information available !

ξ add finalize verb to handle finally-cases in all modules and make only one return although finally does get executed !

ξ review all dragonized lines !!!

ξ replace ALL raise statements and functions with raise statements with your own logic !

ξ replace ALL assert statements and functions with assert statements with raise statements with your own logic Δ

ξ make the system more tunable Δ

ξ review all RETURNS and even if a function or methods does not return a value/function it has accomplished something like verified Δ

ξ review all del statements Δ

ξ REVIEW ALL CLASS VARIABLES such as _address_to_local = {}; _mutex = ForkAwareThreadLock4Xi() of BaseProxy4Xi AND references the dragonized class BaseProxy4Xi , NOT old one such as BaseProxy Δ

ξ mark status review to ALL CLASS VARIABLES

ξ replace ALL assert-statements with if-staments back-ed up by warning or hot-message Δ

ξ improve profile Assistant Studio for G11/G19 keyboard and/or create Production Manager to sense/reason/ace for browsing XML

ξ omega2wait and omega2timeout give wait times individually to modules and at the same time time to others Δ Δ Δ Δ

ξ basemanager4xi.py: process.join(timeout=0.2); process.join(timeout=0.1

ξ forking.py: deadline = time.time() + timeout; calculates deadline duration in seconds !
ξ if self.wait(timeout=0.1) is None:
ξ time.time() gives big number ending to seconds.999999
ξ 0.2 = 0.2 seconds = 200ms
ξ def poll(self, timeout=0.0)

ξ address None should NOT get passed in connections Δ

ξ replace raise such as in in Queue4Xi put for queue full situation with warning !!!

ξ tune timeouts; None may cause system to loop for ever like in Queue4Xi get method Δ

ξ make sure process status is always got ok, not stopped for example is it is running !!!

ξ check all _exposed_ = ; see NameSpaceProxy4Xi, _exposed_ = ('__getattribute__', '__setattr__', '__delattr__' !!!

ξ assert-statements to be replaced with own try-except pairs and own trace Δ

ξ in __init__ use ONLY self. variables and TRY to get some value Δ

ξ once all tagged, develop step-verb and step4xi-macro and replace (Step X/Y) comment blocks wih step4xi macro Δ

ξ _finalizer_registry unresolved !

ξ tag studio4xi programs such as find4py; find4xi; macro4xi !

ξ add (Step /X) to ALL modules - update current ones to take into account branching Δ Δ Δ Δ

ξ utilize tls = thread local storage in sense, reason and ace

ξ consider adding return to functions IF you do NOT want Python compiler to continue processing in your module AS IS DONE OFTEN !!!

ξ mainprocess4xi.py; cant use current_process4xi.py; opopen4xitest_server_mp_xi4.py: ImportError: No module named popen4xi - see mainprocess4xi.py !?

ξ review all dragonized points and change back if required; prefer using self Δ

ξ program set trace and check that only those defined in print4xi.py are traces - not any old objects such as duplicate Δ

ξ develop sense-method so that it reviews all self-requirements to a caller and develop xxxxxxxx_sensor4xi.py where xxxxxxxx = object of Class ZZZZZZZZ

ξ check imports and update macros just in case to import core modules such as from _multiprocessing import win32; Python does NOT check Δ

ξ add inheriting to all classes Δ

ξ consider deleting a) debug b) info c)logger because print4xi replaces them and is better Δ

ξ rename back some to xxxxxxxx Δ

ξ test_all_methods caused Bounded Semaphore exception Δ

ξ CHANGE ASAP class method start messages so that they do NOT try to print self Δ Δ Δ Δ

ξ do NOT consider changing object names i.e. xxxxxxxx-of-token2xi to xxxxxxxx-of-token4xi where class = Toke4Xi - because object refers to to that king of type Δ Δ Δ Δ

ξ check CLASS VARIABLES Δ Δ

ξ program small & smart xxxxxxxx2parse4xi for EACH tag xxxxxxxx because that way you guarantee the best sense, reason, ace stratehy !

ξ profile files in XML for test programs to read and set printing permissions for print4xi.py

ξ to comlete find4py.py create nofind4py.py; for example to find modules NOT containing __all__

ξ test classes Δ Δ

ξ create test_classes4xi.py which calls sense, reason and ace of each class and add more knowledge Δ

ξ you might have to embed some functions, see _check_logger_class2xi.py Δ Δ Δ

ξ __init__.py Δ Δ Δ Δ

ξ check ALL variables x renamed to x2xi in ALL modules - Python compiler does NOT notice erros, see pool4xi.py for example Δ Δ

ξ invent naming to object-variables i.e. to those referred with self Δ

ξ check ALL parameters passed and passing - Python compiler does NOT notice erros Δ Δ

ξ compare ALL modules to original ones Δ Δ Δ Δ Δ Δ Δ Δ

ξ check self.x usage in ALL classes Δ

ξ debug4xi calls to be deleted Δ

ξ import multiprocessing modules referred in OriginalStep Δ

ξ find4py.py in studio could skip checking some modules such as skeleton_print4xi.py - this would decrease output BUT might increase the risk forgetting the setting Δ

ξ Step checker i.e. if (1/4) then has (4(4) been executed and what is the last step executed

ξ develop parse2trace4xi.py to parse tracing messages; for example that message class and method are compatible to function/method/class names

ξ develop object parser; for example to parse xxxxxxxx-of-semlock2xi for SemLock4Xi class

ξ make sure that you do NOT call trace in the way it causes UNNECESSARY CALL or SEMAPHORE reserving Δ

ξ walk-trough ALL modules based on refer4xi tag i.e. compare original modules to those dragonized from it Δ Δ Δ Δ Δ Δ Δ Δ

ξ walk-trough ALL modules with a class and check .self and change to -of-xxxxxxxx2xi format

ξ STEP all modules - the only way to check tagging and make sure calls are in the right place and to offer data to smart parsers and smart tracers in text and xml files! !

ξ invent how to trace calls like _multiprocessing.Connection; passing-to-Connection-of-MultiProcessing ? ; now passing-to-Connection where 4Xi is missing, wgich might identify it ?

ξ mark ALL class variables as xxxxxxxx-of-ZZZZZZZZ where xxxxxxx = class variable and ZZZZZZZZ = class name Δ Δ

ξ to be analyzed class Server4Xi public = and to compare to exposed usage !?

ξ add performed and necessary trace for (StepOriginal) in ALL modules using it Δ Δ

ξ Client and Listener has to analyzed Δ

ξ check that a program does NOT refer to original object/variable which may succeed because of import _multiprocessing *** Δ

DONE
ξ deny_trace
»test_benchmark_mp_xi4
»test_locks_mp_xi4

select: ~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~ Symbolize2actor

Symbolize2actor
ξ »symbolize2actor4xi.py

select: ~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~ Print4Xi

Print4Xi
ξ »print4xi.py
ξ OK = sense, reason and ace-xml files are produced
ξ trace messages get written to MessageKB2Xi OK - why not to all XML-files ?
ξ reason method of print4xi has bug because in xml_trace_reason4xi.py number of keys = 717 < 3191 = number of keys in xml_trace_sense4xi.py
ξ reason uses MessageKB2Xi and gets fetch2scope4xi messages !
ξ bug: reason did NOT skip steps in trace (Step 0A/33) using
ξ ace corrected automatically because it uses reason knowledgebase

Example Settings for Trace

# ------------------------------------------------------------------------------------------------------------------
# [G] Studio4xi
# ------------------------------------------------------------------------------------------------------------------
global generate2image4scope2test <-- (1/7)

# ------------------------------------------------------------------------------------------------------------------
# [G] Studio4xi
# ------------------------------------------------------------------------------------------------------------------
generate2image4scope2test = False <-- (2/7)

# --------------------------------------------------------------------------------------------------------------
# [G] Studio4xi
# --------------------------------------------------------------------------------------------------------------
'generate2image4scope2test': 'NACK4XI', <-- (3/7)

# --------------------------------------------------------------------------------------------------------------
# [G] Studio4xi Statistics
# --------------------------------------------------------------------------------------------------------------
'generate2image4scope2test': 0, <-- (4/7)

# ------------------------------------------------------------------------------------------------------------------
#[G] Studio4xi
# ------------------------------------------------------------------------------------------------------------------
global generate2image4scope2test <-- (5/7)

# ------------------------------------------------------------------------------------------------------------------
#[G] Studio4xi
# ------------------------------------------------------------------------------------------------------------------
generate2image4scope2test = init2xi <-- (6/7)

# ------------------------------------------------------------------------------------------------------------------
#[G] Studio4xi
# ------------------------------------------------------------------------------------------------------------------
'generate2image4scope2test': init2xi, <-- (7/7)

select: ~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~ Dragonizing

Previous Step
ξ »Fetching
ξ fetches required modules from scope4xi folders to be dragonized

Dragonizing
ξ »dragonize2scope4xi.py
ξ dragonizes fecthed programs

ξ possibility to generate dragon module so that it imports from other modules to get it compiled and theregy check its syntax
ξ »apu2image4xi.py
ξ »apu2image4xi5test.py
ξ »apu3image4xi.py
ξ »apu3image4xi5test.py
ξ note: above are temporary files which may have been deleted!

Deployed to Scope4xi
ξ »dragon2image4xi.py
ξ »dragon2image4xi5test.py
ξ »dragon3image4xi.py
ξ »dragon3image4xi5test.py
ξ »version4xi.py
ξ these require other dragonized modules to get tested !
ξ however, they get compiled because they import other functions and classes from apu device functions and classes !

Dragonized
ξ »dragon2image4xi.py
ξ »dragon2image4xi5test.py
ξ »dragon3image4xi.py
ξ »dragon3image4xi5test.py
ξ note: above are temporary files which may have been deleted!

Testing Tips
ξ original as text file
ξ »apu2image4xi5test.py
ξ copy paste from apu2image4xi.txt small pieces for test - otherwise output text file becomes large in the beginning until you reduce trace

select: ~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~ Generating Image Programs for Devices

Generating Image Programs for Devices

Previous Step
ξ »Dragonizing
ξ L:\job\041721\studio4xi\cc\generate\in\lib\dragon\dragon2image4xi.py as output code for virtual device

2D Image Program Generation
ξ »generate2image4scope.py
ξ capable to genera one 2D image processing program at a time
ξ »version4xi.py
ξ ActKB4scope ['b'] ['generate2image4scope'] = 'NACK' <-- 'ACK' to generate
ξ »dragon3image4xi5test.py
ξ output - you may edit it (for example clean embedded trace comment lines) - provided that you remember to deploy edited (and working) one to scope4xi!
ξ note: above file(s) may not exist depending on the latest run!

Generated Programs

2D Image Modules

ξ »apu2image4xi.py
ξ »bpu2image4xi.py
ξ »cpu2image4xi.py
ξ »dpu2image4xi.py
ξ »epu2image4xi.py
ξ »fpu2image4xi.py
ξ »gpu2image4xi.py
ξ »hpu2image4xi.py
ξ »ipu2image4xi.py
ξ »jpu2image4xi.py
ξ »kpu2image4xi.py
ξ »lpu2image4xi.py
ξ »mpu2image4xi.py
ξ »npu2image4xi.py
ξ »opu2image4xi.py
ξ »ppu2image4xi.py
ξ »qpu2image4xi.py
ξ »rpu2image4xi.py
ξ »spu2image4xi.py
ξ »tpu2image4xi.py
ξ »upu2image4xi.py
ξ »vpu2image4xi.py
ξ »wpu2image4xi.py
ξ »xpu2image4xi.py
ξ »ypu2image4xi.py
ξ »zpu2image4xi.py
ξ note: above file(s) may not exist depending on the latest run!

2D Image Test Modules

ξ »apu2image4xi5test.py
ξ »bpu2image4xi5test.py
ξ »cpu2image4xi5test.py
ξ »dpu2image4xi5test.py
ξ »epu2image4xi5test.py
ξ »fpu2image4xi5test.py
ξ »gpu2image4xi5test.py
ξ »hpu2image4xi5test.py
ξ »ipu2image4xi5test.py
ξ »jpu2image4xi5test.py
ξ »kpu2image4xi5test.py
ξ »lpu2image4xi5test.py
ξ »mpu2image4xi5test.py
ξ »npu2image4xi5test.py
ξ »opu2image4xi5test.py
ξ »ppu2image4xi5test.py
ξ »qpu2image4xi5test.py
ξ »rpu2image4xi5test.py
ξ »spu2image4xi5test.py
ξ »tpu2image4xi5test.py
ξ »upu2image4xi5test.py
ξ »vpu2image4xi5test.py
ξ »wpu2image4xi5test.py
ξ »xpu2image4xi5test.py
ξ »ypu2image4xi5test.py
ξ »zpu2image4xi5test.py
ξ note: above file(s) may not exist depending on the latest run!

3D Image Modules

ξ »apu3image4xi.py
ξ »bpu3image4xi.py
ξ »cpu3image4xi.py
ξ »dpu3image4xi.py
ξ »epu3image4xi.py
ξ »fpu3image4xi.py
ξ »gpu3image4xi.py
ξ »hpu3image4xi.py
ξ »ipu3image4xi.py
ξ »jpu3image4xi.py
ξ »kpu3image4xi.py
ξ »lpu3image4xi.py
ξ »mpu3image4xi.py
ξ »npu3image4xi.py
ξ »opu3image4xi.py
ξ »ppu3image4xi.py
ξ »qpu3image4xi.py
ξ »rpu3image4xi.py
ξ »spu3image4xi.py
ξ »tpu3image4xi.py
ξ »upu3image4xi.py
ξ »vpu3image4xi.py
ξ »wpu3image4xi.py
ξ »xpu3image4xi.py
ξ »ypu3image4xi.py
ξ »zpu3image4xi.py
ξ note: above file(s) may not exist depending on the latest run!

2D Image Test Modules

ξ »apu3image4xi5test.py
ξ »bpu3image4xi5test.py
ξ »cpu3image4xi5test.py
ξ »dpu3image4xi5test.py
ξ »epu3image4xi5test.py
ξ »fpu3image4xi5test.py
ξ »gpu3image4xi5test.py
ξ »hpu3image4xi5test.py
ξ »ipu3image4xi5test.py
ξ »jpu3image4xi5test.py
ξ »kpu3image4xi5test.py
ξ »lpu3image4xi5test.py
ξ »mpu3image4xi5test.py
ξ »npu3image4xi5test.py
ξ »opu3image4xi5test.py
ξ »ppu3image4xi5test.py
ξ »qpu3image4xi5test.py
ξ »rpu3image4xi5test.py
ξ »spu3image4xi5test.py
ξ »tpu3image4xi5test.py
ξ »upu3image4xi5test.py
ξ »vpu3image4xi5test.py
ξ »wpu3image4xi5test.py
ξ »xpu3image4xi5test.py
ξ »ypu3image4xi5test.py
ξ »zpu3image4xi5test.py
ξ note: above file(s) may not exist depending on the latest run!

Testing Tips
ξ in the beginning of text copy paste from txt folder source programs only small pieces for processing
ξ generate only one source at a time
ξ note: above file(s) may not exist depending on the latest run!

Work Temp - Fetched Programs As Text Files
ξ »apu2image4xi5test.txt
ξ »apu3image4xi5test.txt
ξ image modules for apu device from scope4xi saved as text files for testing purposes
ξ note: above file(s) may not exist depending on the latest run!

Work Temp - Dragonized Programs As Python
ξ »dragon2image4xi.py
ξ »dragon2image4xi5test.py
ξ »dragon3image4xi.py
ξ »dragon3image4xi5test.py
ξ image modules for virtual dragon device for scope4xi
ξ note: above file(s) may not exist depending on the latest run!

Work Temp - Dragonized Programs As Text Files
ξ »dragon2image4xi5test.txt
ξ »dragon3image4xi5test.txt
ξ image modules for dragon device saved as text files for testing purposes
ξ note: above file(s) may not exist depending on the latest run!

Deploeyd to Scope4xi
ξ »dragon2image4xi.py
ξ »dragon2image4xi5test.py
ξ »dragon3image4xi.py
ξ »dragon3image4xi5test.py
ξ »version4xi.py
ξ image modules for dragon device in scope4xi

select: ~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~ Program Macros

Program Macros

Alphabetical List of Program Macros

[A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W] [X] [Y] [Z]

[A]

abbreviate-c
abbreviate-f
abbreviated-c
abbreviated-f
abbreviating-c
abbreviating-f
abstract-c
abstract-f
abstracted-c
abstracted-f
abstracting-c
abstracting-f
accept-c
accept-f
accepted-c
accepted-f
accepting-c
accepting-f
ace-c
ace-f
aced-c
aced-f
acing-c
acing-f
acknowledge-c
acknowledge-f
acknowledged-c
acknowledged-f
acknowledging-c
acknowledging-f
acquire-c
acquire-f
acquired-c
acquired-f
acquiring-c
acquiring-f
act-c
act-f
acted-c
acted-f
acting-c
acting-f
action-c
action-f
actioned-c
actioned-f
actioning-c
actioning-f
activate-c
activated-c
activating-c
add-c
add-f
added-c
added-f
adding-c
adding-f
analyze-c
analyze-f
analyzed-c
analyzed-f
analyzing-c
analyzing-f
append-c
append-f
appended-c
appended-f
appending-c
appending-f
assert-c
assert-f
asserted-c
asserted-f
asserting-c
asserting-f

[A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W] [X] [Y] [Z]
~[Σ] ~[Ω] ~[Δ]!

[B]

born-c
borning-c
break-c
break-f
breaking-c
breaking-f
broke-c
broke-f
build-c
build-f
building-c
building-f
built-c
built-f

[A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W] [X] [Y] [Z]
~[Σ] ~[Ω] ~[Δ]!

[C]

calculate-c
calculate-f
calculated-c
calculated-f
calculating-c
calculating-f
call-c
call-f
called-c
called-f
calling-c
calling-f
cast-c
cast-f
casting-c
casting-f
check-c
check-f
checked-c
checked-f
checking-c
checking-f
class-c
class-f
classed-c
classed-f
classing-c
classing-f
clear-c
clear-f
cleared-c
cleared-f
clearing-c
clearing-f
close-c
close-f
closed-c
closed-f
closing-c
closing-f
cluster-c
cluster-f
clustered-c
clustered-f
clustering-c
clustering-f
color-c
color-f
colored-c
colored-f
coloring-c
coloring-f
command-c
command-f
commanded-c
commanded-f
commanding-c
commanding-f
comment-c
comment-f
commented-c
commented-f
commenting-c
commenting-f
compare-c
compare-f
compared-c
compared-f
comparing-c
comparing-f
conclude-c
conclude-f
concluded-c
concluded-f
concluding-c
concluding-f
connect-c
connect-f
connected-c
connected-f
connecting-c
connecting-f
contextualize-c
contextualize-f
contextualized-c
contextualized-f
contextualizing-c
contextualizing-f
coordinate-c
coordinate-f
coordinated-c
coordinated-f
coordinating-c
coordinating-f
create-c
create-f
created-c
created-f
creating-c
creating-f

[A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W] [X] [Y] [Z]
~[Σ] ~[Ω] ~[Δ]!

[D]

decide-c
decide-f
decided-c
decided-f
deciding-c
deciding-f
define-c
define-f
defined-c
defined-f
defining-c
defining-f
delete-c
delete-f
deleted-c
deleted-f
deleting-c
deleting-f
deliver-c
deliver-f
delivered-c
delivered-f
delivering-c
delivering-f
did-c
did-f
direct-c
direct-f
directed-c
directed-f
directing-c
directing-f
discard-c
discard-f
discarded-c
discarded-f
discarding-c
discarding-f
disconnect-c
disconnect-f
disconnected-c
disconnected-f
disconnecting-c
disconnecting-f
discover-c
discover-f
discovered-c
discovered-f
discovering-c
discovering-f
dispatch-c
dispatch-f
dispatched-c
dispatched-f
dispatchin-c
dispatching-c
dispatching-f
distance-c
distance-f
distanced-c
distanced-f
distancing-c
distancing-f
do-c
do-f
doing-c
doing-f
done-c
done-f
dragonize-c
dragonize-f
dragonized-c
dragonized-f
dragonizing-c
dragonizing-f
dump-c
dump-f
dumped-c
dumped-f
dumping-c
dumping-f

[A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W] [X] [20Y] [20Z] [20_]
~[Σ] ~[Ω] ~[Δ]!

[E]

embed-c
embedd-f
embedded-c
embedded-f
embedding-c
embedding-f
end-c
end-f
ended-c
ended-f
ending-c
ending-f
enter-c
enter-f
entered-c
entered-f
entering-c
entering-f
examine-c
examine-f
examined-c
examined-f
examining-c
examining-f
expose-c
expose-f
exposed-c
exposed-f
exposing-c
exposing-f

[A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W] [X] [Y] [Z]
~[Σ] ~[Ω] ~[Δ]!

[F]

finalize-c
finalize-f
finalized-c
finalized-f
finalizing-c
finalizing-f
fire-c
fire-f
fired-c
fired-f
firing-c
firing-f
flied-c
flied-f
flush-c
flush-f
flushed-c
flushed-f
flushing-c
flushing-f
fly-c
fly-f
flying-c
flying-f
free-c
free-f
freed-c
freed-f
freeing-c
freeing-f
function-c
function-f
functioned-c
functioned-f
functioning-c
functioning-f

[A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W] [X] [Y] [Z]
~[Σ] ~[Ω] ~[Δ]!

[G]

get-c
get-f
getting-c
getting-f
globalize-c
globalize-f
globalized-c
globalized-f
globalizing-c
globalizing-f
got-c
got-f

[A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W] [X] [Y] [Z]
~[Σ] ~[Ω] ~[Δ]!

[H]

hatch-c
hatch-f
hatched-c
hatched-f
hatching-c
hatching-f
hit-c
hit-f
hitting-c
hitting-f
hunt-c
hunt-f
hunted-c
hunted-f
hunting-c
hunting-f

[A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W] [X] [Y] [Z]
~[Σ] ~[Ω] ~[Δ]!

[I]

idle-c
idle-f
idled-c
idled-f
idling-c
idling-f
ignore-c
ignore-f
ignored-c
ignored-f
ignoring-c
ignoring-f
import-c
import-f
imported-c
imported-f
importing-c
importing-f
impose-c
impose-f
imposed-c
imposed-f
imposing-c
imposing-f
indicate-c
indicate-f
indicated-c
indicated-f
indicating-c
indicating-f
inform-c
inform-f
informed-c
informed-f
informing-c
informing-f
inherit-c
inherited-c
inheriting-c
initialize-c
initialize-f
initialized-c
initialized-f
initializing-c
initializing-f
interface-c
interface-f
interfaced-c
interfaced-f
interfacing-c
interfacing-f

[A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W] [X] [Y] [Z]
~[Σ] ~[Ω] ~[Δ]!

[J]

join-c
join-f
joined-c
joined-f
joining-c
joining-f

[A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W] [X] [Y] [Z]
~[Σ] ~[Ω] ~[Δ]!

[K]

kill-c
kill-f
killed-c
killed-f
killing-c
killing-f

[A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W] [X] [Y] [Z]
~[Σ] ~[Ω] ~[Δ]!

[L]

land-c
land-f
landed-c
landed-f
landing-c
landing-f
launch-c
launch-f
launched-c
launched-f
launching-c
launching-f
link-c
link-f
linked-c
linked-f
linking-c
linking-f
list-c
list-f
listed-c
listed-f
listing-c
listing-f
loop-c
loop-f
looped-c
looped-f
looping-c
looping-f

[A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W] [X] [Y] [Z]
~[Σ] ~[Ω] ~[Δ]!

[M]

manoeuvre-c
manoeuvre-f
manoeuvred-c
manoeuvred-f
manoeuvring-c
manoeuvring-f
master-c
master-f
mastered-c
mastered-f
mastering-c
mastering-f
measure-c
measure-f
measured-c
measured-f
measuring-c
measuring-f
methodize-c
methodize-f
methodized-c
methodized-f
methodizing-c
methodizing-f

[A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W] [X] [Y] [Z]
~[Σ] ~[Ω] ~[Δ]!

[N]

net-c
net-f
netted-c
netted-f
netting-c
netting-f
note-c
note-f
noted-c
noted-f
noting-c
noting-f

[A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W] [X] [Y] [Z]
~[Σ] ~[Ω] ~[Δ]!

[O]

open-c
open-f
opened-c
opened-f
opening-c
opening-f
operate-c
operate-f
operated-c
operated-f
operating-c
operating-f
order-f
ordered-f
ordering-f

[A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W] [X] [Y] [Z]
~[Σ] ~[Ω] ~[Δ]!

[P]

parse-c
parse-f
parsed-c
parsed-f
parsing-c
parsing-f
pass-c
pass-f
passed-c
passed-f
passing-c
passing-f
perform-c
perform-f
performed-c
performed-f
performing-c
performing-f
pickle-c
pickle-f
pickled-c
pickled-f
pickling-c
pickling-f
poll-c
poll-f
polled-c
polled-f
polling-c
polling-f
print-c
print-f
printed-c
printed-f
printing-c
printing-f
private-c
private-f
privated-c
privated-f
privating-c
privating-f
process-c
process-f
processed-c
processed-f
processing-c
processing-f
profile-c
profile-f
profiled-c
profiled-f
profiling-c
profiling-f
program-c
program-f
programmed-c
programmed-f
programming-c
programming-f
protect-c
protect-f
protected-c
protected-f
protecting-c
protecting-f
proxied-c
proxied-f
proxy-c
proxy-f
proxying-c
proxying-f
put-c
put-f
putting-c
putting-f

[A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W] [X] [Y] [Z]
~[Σ] ~[Ω] ~[Δ]!

[Q]

queue-c
queue-f
queued-c
queued-f
queuing-c
queuing-f
quit-c
quit-f
quitted-c
quitted-f
quitting-c
quitting-f

[A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W] [X] [Y] [Z]
~[Σ] ~[Ω] ~[Δ]!

[R]

raise-c
raise-f
raised-c
raised-f
raising-c
raising-f
reason-c
reason-f
reasoned-c
reasoned-f
reasoning-c
reasoning-f
receive-c
receive-f
received-c
received-f
receiving-c
receiving-f
record-c
record-f
recorded-c
recorded-f
recording-c
recording-f
refer-c
refer-f
referred-c
referred-f
referring-c
referring-f
register-c
register-f
registered-c
registered-f
registering-c
registering-f
release-c
release-f
released-c
released-f
releasing-c
releasing-f
remove-c
remove-f
removed-c
removed-f
removing-c
removing-f
rename-c
rename-f
renamed-c
renamed-f
renaming-c
renaming-f
reset-c
reset-f
resetting-c
resetting-f
return-cc
return-cf
return-ec
return-ef
return-fc
return-ff
return-mc
return-mf
return-nc
return-nf
return-tc
return-tf
return-vc
return-vf
return-yc
return-yf
returning-cc
returning-cf
returning-ec
returning-ef
returning-fc
returning-ff
returning-mc
returning-mf
returning-nc
returning-nf
returning-tc
returning-tf
returning-vc
returning-vf
returning-yc
returning-yf
rise-c
rise-f
rising-c
rising-f
rose-c
rose-f
rotate-c
rotate-f
rotated-c
rotated-f
rotating-c
rotating-f
round-c
round-f
rounded-c
rounded-f
rounding-c
rounding-f
run-c
run-f
running-c
running-f

[A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W] [X] [Y] [Z]
~[Σ] ~[Ω] ~[Δ]!

[S]

scheme-c
scheme-f
schemed-c
schemed-f
scheming-c
scheming-f
scope-c
scope-f
scoped-c
scoped-f
scoping-c
scoping-f
select-c
select-f
selected-c
selected-f
selecting-c
selecting-f
send-c
send-f
sending-c
sending-f
sense-c
sense-f
sensed-c
sensed-f
sensin-f
sensing-c
sent-c
sent-f
serve-c
serve-f
served-c
served-f
serving-c
serving-f
set-c
set-f
setting-c
setting-f
share-c
share-f
shared-c
shared-f
sharing-c
sharing-f
show-c
show-f
showed-c
showed-f
showing-c
showing-f
skeletonize-c
skeletonize-f
skeletonized-c
skeletonized-f
skeletonizing-c
skeletonizing-f
skip-c
skip-f
skipped-c
skipped-f
skipping-c
skipping-f
sleep-c
sleep-f
sleeping-c
sleeping-f
slept-c
slept-f
sort-c
sort-f
sorted-c
sorted-f
sorting-c
sorting-f
spawn-c
spawn-f
spawned-c
spawned-f
spawning-c
spawning-f
specialize-c
specialize-f
specialized-c
specialized-f
specializing-c
specializing-f
standardize-c
standardize-f
standardized-c
standardized-f
standardizing-c
standardizing-f
start-c
start-f
started-c
started-f
starting-c
starting-f
state-c
state-f
stated-c
stated-f
stating-c
stating-f
step-c
step-f
stepped-c
stepped-f
stepping-c
stepping-f
super-c
super-f
supering-c
supering-f
superred-c
superred-f
symbolize-c
symbolize-f
symbolized-c
symbolized-f
symbolizing-c
symbolizing-f
synopsize-c
synopsize-f
synopsized-c
synopsized-f
synopsizing-c
synopsizing-f

[A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W] [X] [Y] [Z]
~[Σ] ~[Ω] ~[Δ]!

[T]

tag-c
tag-f
tagged-c
tagged-f
tagging-c
tagging-f
take-into-account-c
take-into-account-f
take-off-c
take-off-f
taken-into-account-c
taken-into-account-f
taken-off-c
taken-off-f
taking-into-account-c
taking-into-account-f
taking-off-c
taking-off-f
tell-c
tell-f
telling-c
telling-f
terminate-c
terminate-f
terminated-c
terminated-f
terminating-c
terminating-f
test-c
test-f
tested-c
tested-f
testing-c
testing-f
time-c
time-f
timed-c
timed-f
timing-c
timing-f
told-c
told-f
took-into-account-c
took-into-account-f
took-off-c
took-off-f
tried-c
tried-f
try-c
try-f
trying-c
trying-f
tune-c
tune-f
tuned-c
tuned-f
tuning-c
tuning-f
type-c
type-f
typed-c
typed-f
typing-c
typing-f

[A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W] [X] [Y] [Z]
~[Σ] ~[Ω] ~[Δ]!

[U]

union-c
union-f
unioned-c
unioned-f
unioning-c
unioning-f
unresolve-c
unresolve-f
unresolved-c
unresolved-f
unresolving-c
unresolving-f
upgrade-c
upgrade-f
upgraded-c
upgraded-f
upgrading-c
upgrading-f
use-c
use-f
used-c
used-f
using-c
using-f

[A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W] [X] [Y] [Z]
~[Σ] ~[Ω] ~[Δ]!

[V]

varied-c
varied-f
vary-c
vary-f
varying-c
varying-f
venture-c
venture-f
ventured-c
ventured-f
venturing-c
venturing-f
verbalize-c
verbalize-f
verbalized-c
verbalized-f
verbalizing-c
verbalizing-f
verge-c
verge-f
verged-c
verged-f
verging-c
verging-f
verified-c
verified-f
verify-c
verify-f
verifying-c
verifying-f
view-c
view-f
viewed-c
viewed-f
viewing-c
viewing-f
visit-c
visit-f
visited-c
visited-f
visiting-c
visiting-f
vote-c
vote-f
voted-c
voted-f
voting-c
voting-f

[A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W] [X] [Y] [Z]
~[Σ] ~[Ω] ~[Δ]!

[W]

wait-c
wait-f
waited-c
waited-f
waiting-c
waiting-f
waive-c
waive-f
waived-c
waived-f
waiving-c
waiving-f
wake-c
wake-f
waking-c
waking-f
walk-c
walk-f
walked-c
walked-f
walking-c
walking-f
wander-c
wander-f
wandered-c
wandered-f
wandering-c
wandering-f
want-c
want-f
wanted-c
wanted-f
wanting-c
wanting-f
warn-c
warn-f
warned-c
warned-f
warning-c
warning-f
warp-c
warp-f
warped-c
warped-f
warping-c
warping-f
wash-c
wash-f
washed-c
washed-f
washing-c
washing-f
watch-c
watch-f
watched-c
watched-f
watching-c
watching-f
wave-c
wave-f
waved-c
waved-f
waving-c
waving-f
weave-c
weave-f
weaved-c
weaved-f
weaving-c
weaving-f
web-c
web-f
webbed-c
webbed-f
webbing-c
webbing-f
weigh-c
weigh-f
weighed-c
weighed-f
weighing-c
weighing-f
wind-c
wind-f
winded-c
winded-f
winding-c
winding-f
wing-c
wing-f
winged-c
winged-f
winging-c
winging-f
wire-c
wire-f
wired-c
wired-f
wiring-c
wiring-f
wise-c
wise-f
wised-c
wised-f
wising-c
wising-f
woke-c
woke-f
wonder-c
wonder-f
wondered-c
wondered-f
wondering-c
wondering-f
wrap-c
wrap-f
wrapped-f
wrapping-f
write-c
write-f
writing-c
writing-f
wrote-c
wrote-f

[A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W] [X] [Y] [Z]
~[Σ] ~[Ω] ~[Δ]!

[X]

x-ray-c
x-ray-f
x-rayed-c
x-rayed-f
x-raying-c
x-raying-f
xray-c
xray-f
xrayed-c
xrayed-f
xraying-c
xraying-f

[A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W] [X] [Y] [Z]
~[Σ] ~[Ω] ~[Δ]!

[Y]

yearn-f
yearned-f
yearning-f
yield-c
yield-f
yielded-c
yielded-f
yielding-c
yielding-f

[A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W] [X] [Y] [Z]
~[Σ] ~[Ω] ~[Δ]!

[Z]

zap-c
zap-f
zapped-c
zapped-f
zapping-c
zapping-f
zero-c
zero-f
zeroed-c
zeroed-f
zeroing-c
zeroing-f
zip-c
zip-f
zipped-c
zipped-f
zipping-c
zipping-f
zone-c
zone-f
zoned-c
zoned-f
zoning-c
zoning-f

[A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W] [X] [Y] [Z]
~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~ Developer Macros

Developer Macros

»macro4xi.py
ξ creates automatically macros to be embedded into source programs
ξ »skeleton_print4xi.py
ξ example program containing -tags
ξ »process4xi.py
ξ example program with emdedded tags
ξ »parse4xi.py
ξ parsing program
ξ »parse2scope4xi.txt
ξ results from parsing

»abstract-e4xi
»abstract4xi
»acknowledge4xi

»class-e4xi
»class2variable-e4xi
»class2variable4xi
»class4xi
»cluster4xi
»comment_boxes
»contextualize4xi

»define2constant-e4xi
»define2constant4xi
»do4xi
»dragonize2import4xi

»end4xi
»expose4xi

»function-e4xi
»function4xi

»globalize2constant4xi
»globalize2dragonxi4xi
»globalize2object4xi

»interface4xi

»link4xi

»methodize-e4xi
»methodize4xi

»note4xi

»pickle4xi
»process2import4xi
»profile4xi
»program-e4xi
»program4xi
»protect4xi

»record4xi
»refer4xi
»register4xi

»scope4xi
»set4xi
»share4xi
»sleep_and_timeout
»specialize2import4xi
»standardize2import4xi
»state4xi
»synopsize4xi

»translate4xi
»type-e4xi
»type4xi

»use4xi

»verbalize-e4xi
»verbalize4xi
»verify4xi

select: ~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~ Tag Profile Codes

Tag Profile Codes
ξ 00 = no functions nor any classes; for example import4xi.py, verb modules, some xml modules, types
ξ 10 = function(s): normal function(s)
ξ 20 = Function(s): special function(s)
ξ 30 = both noremal function(s) and special Function(s)
ξ 01 = stub Class
ξ 02 = normal Class with methods
ξ 03 = Class with embedded functions !
ξ 11 = normal function(s) and normal functions(s); test programs have this profile
ξ 12 = normal function(s) and normal Class(es) with methods
ξ 13 = normal function(s) and both stub Class and normal Class
ξ 21 = special Function(s) and stub Class
ξ 22 = special Function(s) and normal Class with methods
ξ 23 = special Function(s) and both stub Class and normal Class
ξ 31 = both normal function(s) and special Function(s) and stub Class
ξ 32 = both normal function(s) and special Function(s) and special Functions(s)
ξ 33 = ALL

select: ~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~ Verbs and Scoping

Verbs and Scoping

[STEP 1/33] - ADD VERBS INTO SOURCE PROGRAMS
ξ verb definitions are located in source programs verb2?4xi.py, where ? stands for alphabetic starting the verb
ξ (c) cast; color; coordinate; - (d) distance; define - (f) fire -(i) impose -(s) scope; super -(t) time
ξ (c) »verb2c4xi.py
ξ cast; color; coordinate
ξ (d) »verb2d4xi.py
ξ distance; define
ξ (f) »verb2f4xi.py
ξ fire
ξ (i) »verb2i4xi.py
ξ impose
ξ (s) »verb2sxi.py
ξ scope; super
ξ (t) »verb2t4xi.py
ξ time

If you have many verbs to be added, create skeleton for verb - into the corresponding verb2?4xi.py-file (enclosed with verb4xi start and end tag):
'xxxxxxxx': 'xxxxxxxx',
'xxxxxxxxed': 'xxxxxxxxed',
'xxxxxxxxing': 'xxxxxxxxing',
'reference-xxxxxxxxed': yyyyyyyy,
'definition-xxxxxxxx': 'dddddddd',
'symbol-xxxxxxxxing': ssssssss,
'cluster-xxxxxxxxed': cccccccc,
'color-xxxxxxxx': '#FF8000',
'color-xxxxxxxxed': '#FF8000',
'color-xxxxxxxxing': '#FF8000',

[STEP 2/33] - CLUSTER, DEFINE, REFER AND SYMBOLIZE
ξ »verb4xi
ξ ClusterColor4Xi dictionary defines verb clusters for verbs, 21 is the one for scope, cluster
ξ 21: {1: '#3C3C98', 2: '#27277D', 3: '#9797CD', 4: '#1B1B54', 5: 0, 6: 'scoping'}, <-- colors, supercluster 0=theater, 6 = scoping
ξ SuperClusterColor4Xi dictionary defines super clusters 1...8 for verbs
ξ 0: {1: '#9BA2A2', 2: '#8E9292', 3: '#DAE1E1', 4: '#000000', 5: 'theater'},
ξ definition is taken from the dictionary and the page number becomes both symbol and reference
ξ 'reference-scoped': 1718,
ξ 'definition-scope': 'to look at as in order to evaluate.',
ξ 'symbol-scoping': 1718,

[STEP 3/33] - COLOR
ξ »html-color-codes
ξ define colors to all tenses of the verb - base color for tense 1; stronger for tense 2; lighter for tense 3, strongest for tense 4 (if any)

[STEP 4/33] - COMPILE
ξ compile all verbs: >t4v or you can compile each one immediatelly after having edited it) - to fix any syntax errors
ξ compile one: >t verb2f4xi <-- fire verb added, make sure syntax is ok by compiling the source code

[STEP 5/33] - UPDATE CLUSTERS]

ADD SKELETON FOR EACH VERB - into the corresponding cluster2?4xi.py-file (enclosed with cluster4xi start and end tag):
'xxxxxxxx': 21,
'xxxxxxxxed': 21,
'xxxxxxxxing': 21,

ξ »cluster2c4xi.py
ξ cast; color; coordinate
ξ »cluster2d4xi.py
ξ distance; define
ξ »cluster2f4xi.py
ξ fire
ξ »cluster2i4xi.py
ξ impose
ξ »cluster2s4xi.py
ξ scope; super
ξ »cluster2t4xi.py
ξ time
ξ compile all clusters - run t4c.bat to compile all starting with c

[STEP 6/33] - ADD VERB TO SKELETON MESSAGES TO TRACE FUNCTIONS AND METHODS IN SYSTEM
ξ cast; color; coordinate
ξ distance; define
ξ fire
ξ impose
ξ scope; super
ξ time
ξ »skeleton_print4xi.py

CREATE STUB FOR FUNCTIONS AND STUB FOR CLASSES (if several verbs to be added)

# -----------------------------------------------------------------------------------------
# aaaaaaaa, aaaaaaaaED, aaaaaaaaING
# -----------------------------------------------------------------------------------------
#
message2print = "{aaaaaaaa" + "; xxxxxxxx-aaaaaaaa-by-yyyyyyyy: " + str(xxxxxxxx) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#

#
message2print = "{aaaaaaaaed" + "; xxxxxxxx-aaaaaaaaed-by-yyyyyyyy: " + str(xxxxxxxx) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#

#
message2print = "{aaaaaaaaing" + "; xxxxxxxx-aaaaaaaaing-by-yyyyyyyy: " + str(xxxxxxxx) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
aaaaaaaa

# -----------------------------------------------------------------------------------------
# aaaaaaaa, aaaaaaaaed, aaaaaaaaing
# -----------------------------------------------------------------------------------------
#
message2print = "{aaaaaaaa" + "; xxxxxxxx-aaaaaaaa-by-yyyyyyyy-of-ZZZZZZZZ: " + str(xxxxxxxx) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#

#
message2print = "{aaaaaaaaed" + "; xxxxxxxx-aaaaaaaaed-by-yyyyyyyy-of-ZZZZZZZZ: " + str(xxxxxxxx) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
#
message2print = "{aaaaaaaaing" + "; xxxxxxxx-aaaaaaaaing-by-yyyyyyyy-of-ZZZZZZZZ: " + str(xxxxxxxx) + "; time: " + time4xi() + "}"
print4xi(class2print, method2print, message2print)
#
aaaaaaaa

COMPILE SKELETON_PRINT4XI.PY (or run t4s (compiles all starting with s)

[STEP 7/33] - TEST SKELETON_PRINT4XI.PY]
ξ selected Utility Tester profile
ξ run G1=SkeletonPrint (or in command mode: t test_skeleton_print4xi > ..\txt\test_skeleton_print4xi.txt)

[STEP 8/33] - VIEW REASON-TEST-SKELETON-PRINT4XI.XML
ξ »reason-test-skeleton-print4xi.xml
ξ find ALL verb tenses and TWICE i.e. one for function and one for class message
ξ [ack] cast; [ack] color; [ack] coordinate
ξ [ack] define ; [ack] distance
ξ [ack] fire
ξ [ack] impose
ξ [ack] scope; [ack] super
ξ [ack] time
ξ TIP: if you do NOT find all messages to all verb tenses, problem is often a verb-module
ξ for example firing tense did not appear and the error was in module fire2xi4xi.py where it was mispelled as fireing

[STEP 9/33] - RUN TEST_VERBKB4XI.PY
ξ selected Utility Tester profile
ξ in M1 run G4 = Verbs (or in command mode run: t test_verbkb4xi >..\txt\test_verbkb4xi.txt)

[STEP 10/33] - VIEW REASON-VERB4XI.XML
ξ »reason-verb4xi.xml
ξ this test also verified compilation of verb modules - you can perform this step 12 also earlier, for example before Step 5
ξ [ack] cast; [ack] color; [ack] coordinate
ξ [ack] define ; [ack] distance
ξ [ack] fire
ξ [ack] impose
ξ [ack] scope; [nack] super
ξ [ack] time
ξ TIP: if you do NOT see a verb there, but the verb exists in reason-test-skeleton-print4xi.xml ...

[STEP 11/33] - RUN TEST_COORDINATE4XI.PY
ξ selected Module Tester
ξ run G2=Test Coordinate4xi (or in command mode run: t test_coordinate4xi >..\txt\test_coordinate4xi.txt)

[STEP 12/33] - VIEW SCOPE-TEST-SKELETON-PRINT4XI.XML
ξ »scope-reason-test-skeleton-print4xi.xml
ξ found scheme tenses - each twice

[STEP 13/33] - RUN MACRO GENERATOR
ξ go2studio in command mode
ξ selected Assistant of Studio profile and run G2 = Macro created, or in command mode >macro4xi (or >c macro4xi > ..\txt\macro4xi.txt)

[STEP 14/33] - CHECK MACROS
ξ cast; color; coordinate
ξ define ; distance
ξ fire
ξ impose
ξ scope; [ack] super
ξ time
for example the following macros were created to help tracing scope-verb in its all tenses:
ξ »scope-c
ξ »scoped-c
ξ »scoping-c
ξ »scope-f
ξ »scoped-f
ξ »scoping-f

[STEP 15/33] - TEST MACROS - (you don't have to have a smart keyboard, just use editor!)
ξ selected ProgramDeveloper4Xi profile
ξ picked an Unassigned key - G18 was picked for scope-c.txt macro-file just as an example to be used to add this skeleton to a program
ξ »scope-c

[STEP 16/33] - CREATE MACRO FILES FOR DEVELOPERS - (you don't have to have a smart keyboard, just use editor!)
ξ in Notepad editor opened cluster4xi.txt in \Studio4Xi\c4xi\profile\developer4xi\program4xi folder
ξ saved it as scope4xi.txt
ξ »scope4xi

[STEP 17/33] - CREATE KEYBOARD MACROS FOR DEVELOPERS - (skip this step if you don' use smart keyboards!)
ξ selected ProgramDeveloper
ξ in Logitech G11 picked G18 Unassigned and created scope4xi with 8ms delay between characters

[STEP 18/33] - TEST KEYBOARD MACROS CREATED FOR DEVELOPERS - (skip this step if you don' use smart keyboards!)
ξ opened a new file in editor and tested G18-key
ξ »scope4xi

[STEP 19/33] - USING STUDIO4XI TO FIND POSSIBLE ERRORS - (skip this step if you don' use smart keyboards!)
ξ find out which program writes reason-verb4xi.xml
ξ edit SEARCH PATTERNS in find4py.py
ξ »find4py.py

[STEP 20/33] - SELECTING Assistant of Studio PROFILE - (skip this step if you don' use smart keyboards!)
ξ select Assistant of Studio
ξ run G5= Find in Python source (or in command mode run >find4py)

[STEP 21/33] - SEARCHING ERRORS IN FIND4PY.TXT - (skip this step if you don' use smart keyboards!)
ξ search text reason-verb4xi.xml in find4py.txt
ξ »find4py.txt
ξ *** line: {'file_path4xi': '..\\..\\xml\\reason-verb4xi.xml',
ξ function updating reason-verb4xi.xml is xml_verb4xi located in the module

[STEP 22/33] - CHECKING KEYBOARD PROFILES AND MACROS - (skip this step if you don' use smart keyboards!)
ξ how to find out which macro key created E:\Sw4Xi\Python31\xml\reason-verb4xi.xml and how to fix a bug
ξ file has Version Date and Time so you can try all keys in all profiles!
ξ Commander4Xi: M1: not, M2:not, M3:not
ξ Utility Tester: M1: G4 = t xml_verb >..\txt\test_verbkb4xi.txt <-- YES
ξ Version Sat, 02 Oct 2010 09:19:14 <-- Version Sat, 02 Oct 2010 09:20:32
ξ Verb4Xi method xml_verb calls xml_verb4xi-function
ξ »test_verbkb4xi.py
ξ test_verbkb4xi.py is the one: v2xi.xml_verb() #TEST_VERBKB4XI: XML BY CLASS CREATED XML FILE REASON-VERB4XI.XML
ξ xml_verb4xi-function is the one with bug: when it met cluster, it repeated cluster-_pertained... to all verbs
ξ when it met color, it repeated color- with others failing to print color-tenses!
ξ reason_verb4xi-function of verb4xi.py is the guilty one !

[STEP 32/33] - SUMMARY
ξ »verb4xi.py and »verb2_4xi.py ... »verb2s4xi.py alphabetically »test_verbkb4xi.py with test program
ξ »cluster2a4xi.py ... »cluster2z4xi.py
ξ »skeleton_print4xi.py »test_skeleton_print4xi.py »reason-test-skeleton-print4xi.xml »scope-reason-test-skeleton-print4xi.xml
ξ »test_coordinate4xi.py »reason-verb4xi.xml »scope-reason-verb4xi.xml

[STEP 33/33] - CLASSIC EXAMPLE
ξ »hello_world4xi.py (run: >hello_world4xi or compile and run: >t hello_world4xi > ..\txt\hello_world4xi.txt)
ξ »hello_world4xi.txt »reason-hello-world4xi.xml »sense-hello-world4xi.xml »ace-hello-world4xi.xml
ξ »scope-reason-hello-world4xi.xml »scope-sense-hello-world4xi.xml »scope-acehello-world4xi.xml

select: ~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~Profiles for Keyboard

Profiles for Keyboard

»AssistantStudio M1
»AssistantStudio M2
»AssistantStudio M3

»CommanderProfile M1
»CommanderProfile M2
»CommanderProfile M3

»ModuleTesterProfile M1
»ModuleTesterProfile M2
»ModuleTesterProfile M3

»Surfer2Web4Xi M1
»Surfer2Web4Xi M2
»Surfer2Web4Xi M3

»UtilityTesterProfile M1
»UtilityTesterProfile M2
»UtilityTesterProfile M3

Notes
ξ M1, M2 and M3 depict modes inside each profile
ξ with G19 and G11 assign macros as text block and define 8 millisecond delay between characters!
ξ G11 can manage 12 and G11 up to 18 buttons
ξ you can use either of both keyboards and Key Profiles works for both!

select: ~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~Utility Tester Profile

Utility Tester Profile

M1 of Utility Tester Profile

G1
SkeletonPrint
t test_skeleton_print4xi > ..\txt\test_skeleton_print4xi.txt

G2
Pickle
t test_pickle4xi > ..\txt\test_pickle4xi.txt

G3
Print
t test_print4xi > ..\txt\test_print4xi.txt

G4
Verbs
t test_verbkb4xi >..\txt\test_verbkb4xi.txt

G5
After-Fork
t test_after_fork4xi > ..\txt\test_after_fork4xi.txt

G6
Z-Skeleton $
t test_zskeleton4xi > ..\txt\test_zskeleton4xi.txt

G7
Ball
t test_ball4xi >..\txt\test_ball4xi.txt

G8
Time
t test_time4xi > ..\txt\test_time4xi.txt

TimeOut
t test_timeout4xi > ..\txt\test_timeout4xi.txt

G10
Date
t test_date4xi > ..\txt\test_date4xi.txt

G11
CPU-Core-Count
t test_cpu_corecount4xi > ..\txt\test_cpu_corecount4xi.txt

G12
Logger
t test_logger4xi > ..\txt\test_logger4xi.txt

------------------------------------------------------------------------------------
G13
FREE
t test_xxxxxxxx4xi > ..\txt\test_xxxxxxxx4xi.txt

G14
FREE
t test_xxxxxxxx4xi > ..\txt\test_xxxxxxxx4xi.txt

G15
FREE
t test_xxxxxxxx4xi > ..\txt\test_xxxxxxxx4xi.txt

G16
FREE
t test_xxxxxxxx4xi > ..\txt\test_xxxxxxxx4xi.txt

G17
FREE
t test_xxxxxxxx4xi > ..\txt\test_xxxxxxxx4xi.txt

G18
FREE
t test_xxxxxxxx4xi > ..\txt\test_xxxxxxxx4xi.txt

M2 of Utility Tester Profile

G1
Heap-C
t test_constant_heap4xi > ..\txt\test_constant_heap4xi.txt

G2
System-C
t test_constant_system4xi > ..\txt\test_constant_system4xi.txt

G3
Logger-C
t test_constant_logger4xi > ..\txt\test_constant_logger4xi.txt

G4
Connection-C
t test_constant_connection4xi > ..\txt\test_constant_connection4xi.txt

G5
Managers-C
t test_constant_managers4xi > ..\txt\test_constant_managers4xi.txt

G6
Util-C
t test_constant_util4xi > ..\txt\test_constant_util4xi.txt

G7
Family-C
t test_constant_family4xi > ..\txt\test_constant_family4xi.txt

G8
Forking-C
t test_constant_forking4xi > ..\txt\test_constant_forking4xi.txt

G9
Synchronize-C
t test_constant_synchronize4xi >..\txt\test_constant_synchronize4xi.txt

G10
Process-C
t test_constant_process4xi >..\txt\test_constant_process4xi.txt

G11
Synchronize-C
t test_constant_synchronize4xi >..\txt\test_constant_synchronize4xi.txt

G12
Pool-C
t test_constant_pool4xi > ..\txt\test_constant_pool4xi.txt

------------------------------------------------------------------------------------
G13
FREE
t test_xxxxxxxx4xi > ..\txt\test_xxxxxxxx4xi.txt

G14
FREE
t test_xxxxxxxx4xi > ..\txt\test_xxxxxxxx4xi.txt

G15
FREE
t test_xxxxxxxx4xi > ..\txt\test_xxxxxxxx4xi.txt

G16
FREE
t test_xxxxxxxx4xi > ..\txt\test_xxxxxxxx4xi.txt

G17
FREE
t test_xxxxxxxx4xi > ..\txt\test_xxxxxxxx4xi.txt

G18
FREE
t test_xxxxxxxx4xi > ..\txt\test_xxxxxxxx4xi.txt

M3 of Utility Tester Profile

G1
Original-Dir
t test_original_dir4xi > ..\txt\test_original_dir4xi.txt

G2
Format
t test_format4xi > ..\txt\test_format4xi.txt

G3
Arena
t test_arena4xi > ..\txt\test_arena4xi.txt

G4
Finalize
t test_finalize4xi > ..\txt\test_finalize4xi.txt

G5
K-skeleton
t test_kskeleton4xi > ..\txt\test_kskeleton4xi.txt

G6
U-Skeleton
t test_uskeleton4xi > ..\txt\test_uskeleton4xi.txt

G7
Process Local Set
t test_processlocalset4xi > ..\txt\test_processlocalset4xi.txt

G8
Logger
t test_logger4xi > ..\txt\test_logger4xi.txt

G9
Value4Xi
t test_value4xi > ..\txt\test_value4xi.txt

G10
State4Xi
t test_state4xi > ..\txt\test_state4xi.txt

G11
S-Server4Xi
t test_server4xi > ..\txt\test_server4xi.txt

G12
Y-Skeleton
t test_yskeleton4xi > ..\txt\test_yskeleton4xi.txt

------------------------------------------------------------------------------------
G13
FREE
t test_xxxxxxxx4xi > ..\txt\test_xxxxxxxx4xi.txt

G14
FREE
t test_xxxxxxxx4xi > ..\txt\test_xxxxxxxx4xi.txt

G15
FREE
t test_xxxxxxxx4xi > ..\txt\test_xxxxxxxx4xi.txt

G16
FREE
t test_xxxxxxxx4xi > ..\txt\test_xxxxxxxx4xi.txt

G17
FREE
t test_xxxxxxxx4xi > ..\txt\test_xxxxxxxx4xi.txt

G18
FREE
t test_xxxxxxxx4xi > ..\txt\test_xxxxxxxx4xi.txt

select: ~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~Multicore CPU sensing

»cpu_corecount4xi.py
»test_cpu_corecount4xi.py
ξ run count2core4xi.bat

select: ~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~Commander Profile

Commander Profile

M1 of Commander Profile

G1
go2multicore

e:
cd e:\sw4xi\Python31\bat
call iceautoexec
path
echo ready!

G2
Hello-World4Xi

t hello_world4xi > ..\txt\hello_world4xi.txt

G3
ValueProxy

t test_valueproxy4xi > ..\txt\test_valueproxy4xi.txt

G4
Value
t test_value4xi >..\txt\test_value4xi.txt

G5
Token

t test_token4xi >..\txt\test_token4xi.txt

G6
SyncManager

t test_syncmanager4xi >..\txt\test_syncmanager4xi.txt

G7
AcquirerProxy

t test_acquirerproxy4xi >..\txt\test_acquirerproxy4xi.txt

G8
ArrayProxy

t test_arrayproxy4xi >..\txt\test_arrayproxy4xi.txt

G9
AutoProxy

t test_autoproxy4xi >..\txt\test_autoproxy4xi.txt

G10
Array

t test_array4xi >..\txt\test_array4xi.txt

G11
Current Process ***

t test_current_process4xi > ..\txt\test_current_process4xi

G12
BaseListProxy ***

t test_baselistproxy4xi >..\txt\test_baselistproxy4xi.txt

------------------------------------------------------------------------------------
G13
PoolProxy
t test_poolproxy4xi >..\txt\test_poolproxy4xi.txt

G14
ProcessLocalSet
t test_processlocalset4xi >..\txt\test_processlocalset4xi.txt

G15
Public Methods ***
t test_public_methods4xi >..\txt\test_public_methods4xi.txt

G16
RebuildAsList
t test_rebuild_as_list4xi >..\txt\test_rebuild_as_list4xi.txt

G17
RebuildProxy
t test_rebuildproxy4xi >..\txt\test_rebuildproxy4xi.txt

G18
Reduce Array
t test_reduce_array4xi >..\txt\test_reduce_array4xi.txt
M2 of Commander Profile

G1
Compile-All4Xi

c_all4xi

G2
BaseManager

t test_basemanager4xi > ..\txt\test_basemanager4xi.txt

G3
Proxy-MP-Xi4

t test_proxy_mp_xi4 >..\txt\test_proxy_mp_xi4.txt

G4
Hello-DragonXi

t hello_world4xi "Hello DragonXi" --multiprocessing-fork >..\txt\hello_world4xi.txt

G5
Hello-Pipe4xi

t hello_pipe4xi >..\txt\test_hello_pipe4xi.txt

G6
All-Methods4Xi

t test_all_methods4xi >..\txt\test_all_methods4xi.txt

G7
BaseProxy

t test_baseproxy4xi > ..\txt\test_baseproxy4xi.txt

G8
ConditionProxy

t test_conditionproxy4xi > ..\txt\test_conditionproxy4xi.txt

G9
ConverToError
t test_convert_to_error4xi > ..\txt\test_convert_to_error4xi.txt

G10
After-Fork

t test_after_fork4xi > ..\txt\test_after_fork4xi.txt

G11
Degug-Info

t test_debug_info4xi > ..\txt\test_debug_info4xi.txt

G12
DictProxy

t test_dictproxy4xi > ..\txt\test_dictproxy4xi.txt

------------------------------------------------------------------------------------
G13
RemoteError
t test_remoteerror4xi > ..\txt\test_remoteerror4xi.txt

G14
Server4Xi
t test_server_mp_xi4 > ..\txt\test_server4xi.txt

G15
Ctypes MP Xi4 Test
t test_ctypes_mp_xi4 > ..\txt\test_ctypes_mp_xi4.txt

G16
Math Test
t test_math_mp_xi4 > ..\txt\test_math4xi.txt

G17
Pool One MP Xi4
t test_pool1_mp_xi4 > ..\txt\test_pool1_mp_xi4.txt

G18
Processref MP Xi4 Test
t test_processref_mp_xi4 > ..\txt\test_processref_mp_xi4.txt

M3 of Commander Profile

G1
SharedCtypes
t test_sharedctypes4xi >..\txt\test_sharedctypes4xi.txt

G2
Dispatch
t test_dispatch4xi > ..\txt\test_dispatch4xi.txt

G3
EventProxy
t test_eventproxy4xi > ..\txt\test_eventproxy4xi.txt

G4
IteratorProxy
t test_iteratorproxy4xi > ..\txt\test_iteratorproxy4xi.txt

G5
Listener Client
t test_listener_client4xi > ..\txt\test_listener_client4xi.txt

G6
ListProxy
t test_listproxy4xi > ..\txt\test_listproxy4xi.txt

G7
MakeProxyType
t test_makeproxytype4xi > ..\txt\test_makeproxytype4xi.txt

G8
Current-Process4Xi
t test_current_process4xi > ..\txt\test_current_process4xi.txt

G9
LOCKS
t test_locks_mp_xi4 > ..\txt\test_locks_mp_xi4

G10
Manager
t test_manager4xi > ..\txt\test_manager4xi.txt

G11
NameSpace
t test_namespace4xi > ..\txt\test_namespace4xi.txt

G12
NamespaceProxy
t test_namespaceproxy4xi > ..\txt\test_namespaceproxy4xi.txt

------------------------------------------------------------------------------------
G13
State
t test_state4xi > ..\txt\test_state4xi.txt

G14
RebuildProxy
t test_rebuildproxy4xi > ..\txt\test_rebuildproxy4xi.txt

G15
Sleep4Xi
t test_sleep4xi > ..\txt\test_sleep4xi.txt

G16
Pipe1 MP Xi4
t test_pipe1_mp_xi4 > ..\txt\test_pipe1_mp_xi4.txt

G17
Dummy Process
t test_dummy_process4xi > ..\txt\test_dummy_process4xi.txt

G18
BENCMARK
t test_benchmark_mp_xi4 > ..\txt\test_benchmark_mp_xi4.txt

select: ~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~Module Tester Profile

Module Tester Profile

M1 of Module Tester Profile

G1
TimeOut
t test_timeout4xi > ..\txt\test_timeout4xi.txt

G2
Pickle
t test_pickle4xi > ..\txt\test_pickle4xi.txt

G3
Sphere
echo %date% - %time% - starting
t test_sphere4xi > ..\txt\test_sphere4xi.txt
echo %date% - %time% - done!

G4
Copy100Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one1004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two1004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three1004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four1004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five1004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six1004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven1004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight1004xi.txt
echo %date% - %time% - done!

G5
Copy200Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one2004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two2004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three2004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four2004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five2004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six2004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven2004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight2004xi.txt
echo %date% - %time% - done!

G6
Copy300Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one3004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two3004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three3004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four3004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five3004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six3004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven3004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight3004xi.txt
echo %date% - %time% - done!

G7
Copy400Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one4004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two4004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three4004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four4004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five4004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six4004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven4004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight4004xi.txt
echo %date% - %time% - done!

G8
Copy500Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one5004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two5004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three5004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four5004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five5004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six5004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven5004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight5004xi.txt
echo %date% - %time% - done!

G9
Copy600Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one6004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two6004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three6004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four6004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five6004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six6004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven6004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight6004xi.txt
echo %date% - %time% - done!

G10
Copy700Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one7004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two7004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three7004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four7004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five7004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six7004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven7004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight7004xi.txt
echo %date% - %time% - done!

G11
Copy800Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one8004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two8004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three8004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four8004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five8004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six8004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven8004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight8004xi.txt
echo %date% - %time% - done!

G12
Copy900Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one9004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two9004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three9004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four9004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five9004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six9004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven9004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight9004xi.txt
echo %date% - %time% - done!

------------------------------------------------------------------------------------
G13
Copy1000Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one10004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two10004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three10004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four10004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five10004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six10004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven10004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight10004xi.txt
echo %date% - %time% - done!

G14
Copy1100Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one11004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two11004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three11004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four11004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five11004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six11004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven11004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight11004xi.txt
echo %date% - %time% - done!

G15
Copy1200Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one12004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two12004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three12004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four12004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five12004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six12004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven12004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight12004xi.txt
echo %date% - %time% - done!

G16
Copy1300Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one13004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two13004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three13004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four13004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five13004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six13004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven13004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight13004xi.txt
echo %date% - %time% - done!

G17
Copy1400Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one14004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two14004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three14004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four14004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five14004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six14004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven14004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight14004xi.txt
echo %date% - %time% - done!

G18
Copy1500Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one15004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two15004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three15004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four15004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five15004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six15004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven15004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight15004xi.txt
echo %date% - %time% - done!

M2 of Module Tester Profile

G1
Copy1600Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one16004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two16004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three16004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four16004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five16004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six16004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven16004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight16004xi.txt
echo %date% - %time% - done!

G2
Copy1700Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one17004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two17004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three17004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four17004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five17004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six17004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven17004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight17004xi.txt
echo %date% - %time% - done!

G3
Copy1800Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one18004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two18004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three18004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four18004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five18004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six18004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven18004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight18004xi.txt
echo %date% - %time% - done!

G4
Copy1900Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one19004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two19004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three19004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four19004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five19004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six19004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven19004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight19004xi.txt
echo %date% - %time% - done!

G5
Copy2000Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one20004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two20004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three20004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four20004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five20004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six20004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven20004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight20004xi.txt
echo %date% - %time% - done!

G6
Copy2100Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one21004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two21004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three21004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four21004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five21004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six21004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven21004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight21004xi.txt
echo %date% - %time% - done!

G7
Copy2200Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one22004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two22004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three22004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four22004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five22004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six22004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven22004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight22004xi.txt
echo %date% - %time% - done!

G8
Copy2300Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one23004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two23004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three23004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four23004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five23004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six23004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven23004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight23004xi.txt
echo %date% - %time% - done!

G9
Copy2400Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one24004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two24004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three24004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four24004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five24004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six24004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven24004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight24004xi.txt
echo %date% - %time% - done!

G10
Copy2500Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one25004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two25004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three25004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four25004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five25004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six25004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven25004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight25004xi.txt
echo %date% - %time% - done!

G11
Copy2600Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one26004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two26004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three26004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four26004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five26004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six26004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven26004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight26004xi.txt
echo %date% - %time% - done!

G12
Copy2700Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one27004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two27004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three27004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four27004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five27004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six27004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven27004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight27004xi.txt
echo %date% - %time% - done!

------------------------------------------------------------------------------------
G13
Copy2800Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one28004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two28004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three28004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four28004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five28004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six28004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven28004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight28004xi.txt
echo %date% - %time% - done!

G14
Copy2900Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one29004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two29004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three29004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four29004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five29004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six29004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven29004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight29004xi.txt
echo %date% - %time% - done!

G15
Copy3000Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one30004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two30004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three30004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four30004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five30004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six30004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven30004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight30004xi.txt
echo %date% - %time% - done!

G16
Copy3100Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one31004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two31004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three31004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four31004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five31004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six31004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven31004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight31004xi.txt
echo %date% - %time% - done!

G17
Copy3200Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one32004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two32004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three32004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four32004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five32004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six32004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven32004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight32004xi.txt
echo %date% - %time% - done!

G18
Copy3300Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one33004xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two33004xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three33004xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four33004xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five33004xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six33004xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven33004xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight33004xi.txt
echo %date% - %time% - done!

M3 of Module Tester Profile

G1
Copy10Sphere
echo %date% - %time% - starting to copy
copy ..\txt\shot2one4xi.txt ..\txt\shot2one104xi.txt
copy ..\txt\shot2two4xi.txt ..\txt\shot2two104xi.txt
copy ..\txt\shot2three4xi.txt ..\txt\shot2three104xi.txt
copy ..\txt\shot2four4xi.txt ..\txt\shot2four104xi.txt
copy ..\txt\shot2five4xi.txt ..\txt\shot2five104xi.txt
copy ..\txt\shot2six4xi.txt ..\txt\shot2six104xi.txt
copy ..\txt\shot2seven4xi.txt ..\txt\shot2seven104xi.txt
copy ..\txt\shot2eight4xi.txt ..\txt\shot2eight104xi.txt
echo %date% - %time% - done!

G2
Test Coordinate4Xi
t test_coordinate4xi >..\txt\test_coordinate4xi.txt

G3

G4

G5

G6

G7

G8

G9

G10

G11

G12

------------------------------------------------------------------------------------
G13

G14

G15

G16

G17

G18

select: ~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~Scoped sense-, ace- and reason-XML-files

Directions & coordinates
# ONE - (X + ,Y + ,Z + )
# TWO - (X + ,Y - ,Z - )
# THREE - (X + ,Y + ,Z - )
# FOUR - (X + ,Y - ,Z + )
# FIVE - (X - ,Y + ,Z + )
# SIX - (X - ,Y + ,Z - )
# SEVEN - (X - ,Y - ,Z + )
# EIGHT - (X - ,Y - ,Z - )

Scoped Sense XML-files
ξ »scope-sense-all-methods4xi
ξ »scope-sense-ctypes4xi
ξ »scope-sense-current-process4xi
ξ »scope-sense-dummy-process4xi
ξ »scope-sense-finalize4xi
ξ »scope-sense-hello-pipe4xi
ξ »scope-sense-hello-world4xi
ξ »scope-sense-math-two-4xi
ξ »scope-sense-math4xi
ξ »scope-sense-pickle4xi
ξ »scope-sense-pipe1-test4xi
ξ »scope-sense-pool-one-4xi
ξ »scope-sense-processref4xi
ξ »scope-sense-proxy-mp-test4xi
ξ »scope-sense-public-methods-test4xi
ξ »scope-sense-server4xi
ξ »scope-sense-sleep4xi
ξ »scope-sense-sync-manager-test4xi
ξ »scope-sense-test-after_fork4xi
ξ »scope-sense-test-arena4xi
ξ »scope-sense-test-ball4xi
ξ »scope-sense-test-benchmark4xi
ξ »scope-sense-test-constant-connection4xi
ξ »scope-sense-test-constant-family4xi
ξ »scope-sense-test-constant-forking4xi
ξ »scope-sense-test-constant-heap4xi
ξ »scope-sense-test-constant-logger4xi
ξ »scope-sense-test-constant-managers4xi
ξ »scope-sense-test-constant-pool4xi
ξ »scope-sense-test-constant-process4xi
ξ »scope-sense-test-constant-synchronize4xi
ξ »scope-sense-test-constant-system4xi
ξ »scope-sense-test-constant-util4xi
ξ »scope-sense-test-cpu-corecount4xi
ξ »scope-sense-test-format4xi
ξ »scope-sense-test-kskeleton4xi
ξ »scope-sense-test-locks4xi
ξ »scope-sense-test-logger4xi
ξ »scope-sense-test-manager4xi
ξ »scope-sense-test-original-dir4xi
ξ »scope-sense-test-server4xi
ξ »scope-sense-test-shared-ctypes4xi
ξ »scope-sense-test-skeleton-print4xi
ξ »scope-sense-test-sphere4xi
ξ »scope-sense-test-state4xi
ξ »scope-sense-test-uskeleton4xi
ξ »scope-sense-test-yskeleton4xi
ξ »scope-sense-test-zskeleton4xi
ξ »scope-sense-timeout4xi
ξ »scope-sense-token4xi
ξ »scope-sense-value-proxy4xi
ξ »scope-sense-value-test4xi

Scoped Ace XML-files
ξ »scope-ace-all-methods4xi
ξ »scope-ace-current-process4xi
ξ »scope-ace-dummy-process4xi
ξ »scope-ace-finalize4xi
ξ »scope-ace-hello-pipe4xi
ξ »scope-ace-hello-world4xi
ξ »scope-ace-math-two-4xi
ξ »scope-ace-math4xi
ξ »scope-ace-pickle4xi
ξ »scope-ace-pipe1-test4xi
ξ »scope-ace-pool-one-4xi
ξ »scope-ace-processref4xi
ξ »scope-ace-proxy-mp-test4xi
ξ »scope-ace-public-methods-test4xi
ξ »scope-ace-server4xi
ξ »scope-ace-sleep4xi
ξ »scope-ace-sync-manager-test4xi
ξ »scope-ace-test-after_fork4xi
ξ »scope-ace-test-arena4xi
ξ »scope-ace-test-ball4xi
ξ »scope-ace-test-benchmark4xi
ξ »scope-ace-test-constant-connection4xi
ξ »scope-ace-test-constant-family4xi
ξ »scope-ace-test-constant-forking4xi
ξ »scope-ace-test-constant-heap4xi
ξ »scope-ace-test-constant-logger4xi
ξ »scope-ace-test-constant-managers4xi
ξ »scope-ace-test-constant-pool4xi
ξ »scope-ace-test-constant-process4xi
ξ »scope-ace-test-constant-synchronize4xi
ξ »scope-ace-test-constant-system4xi
ξ »scope-ace-test-constant-util4xi
ξ »scope-ace-test-cpu-corecount4xi
ξ »scope-ace-test-format4xi
ξ »scope-ace-test-kskeleton4xi
ξ »scope-ace-test-locks4xi
ξ »scope-ace-test-logger4xi
ξ »scope-ace-test-manager4xi
ξ »scope-ace-test-original-dir4xi
ξ »scope-ace-test-server4xi
ξ »scope-ace-test-shared-ctypes4xi
ξ »scope-ace-test-skeleton-print4xi
ξ »scope-ace-test-sphere4xi
ξ »scope-ace-test-state4xi
ξ »scope-ace-test-uskeleton4xi
ξ »scope-ace-test-yskeleton4xi
ξ »scope-ace-test-zskeleton4xi
ξ »scope-ace-timeout4xi
ξ »scope-ace-token4xi
ξ »scope-ace-value-proxy4xi
ξ »scope-ace-value-test4xi

Scoped Reason XML-files
ξ »scope-reason-verb4xi.xml
ξ »scope-reason-all-methods4xi
ξ »scope-reason-current-process4xi
ξ »scope-reason-dummy-process4xi
ξ »scope-reason-finalize4xi
ξ »scope-reason-hello-pipe4xi
ξ »scope-reason-hello-world4xi
ξ »scope-reason-math-two-4xi
ξ »scope-reason-math4xi
ξ »scope-reason-pickle4xi
ξ »scope-reason-pipe1-test4xi
ξ »scope-reason-pool-one-4xi
ξ »scope-reason-processref4xi
ξ »scope-reason-proxy-mp-test4xi
ξ »scope-reason-public-methods-test4xi
ξ »scope-reason-server4xi
ξ »scope-reason-sleep4xi
ξ »scope-reason-sync-manager-test4xi
ξ »scope-reason-test-after_fork4xi
ξ »scope-reason-test-arena4xi
ξ »scope-reason-test-benchmark4xi
ξ »scope-reason-test-constant-connection4xi
ξ »scope-reason-test-constant-family4xi
ξ »scope-reason-test-constant-forking4xi
ξ »scope-reason-test-constant-heap4xi
ξ »scope-reason-test-constant-logger4xi
ξ »scope-reason-test-constant-managers4xi
ξ »scope-reason-test-constant-pool4xi
ξ »scope-reason-test-constant-process4xi
ξ »scope-reason-test-constant-synchronize4xi
ξ »scope-reason-test-constant-system4xi
ξ »scope-reason-test-constant-util4xi
ξ »scope-reason-test-cpu-corecount4xi
ξ »scope-reason-test-format4xi
ξ »scope-reason-test-kskeleton4xi
ξ »scope-reason-test-locks4xi
ξ »scope-reason-test-logger4xi
ξ »scope-reason-test-manager4xi
ξ »scope-reason-test-original-dir4xi
ξ »scope-reason-test-server4xi
ξ »scope-reason-test-shared-ctypes4xi
ξ »scope-reason-test-skeleton-print4xi
ξ »scope-reason-test-sphere4xi
ξ »scope-reason-test-state4xi
ξ »scope-reason-test-uskeleton4xi
ξ »scope-reason-test-yskeleton4xi
ξ »scope-reason-test-zskeleton4xi
ξ »scope-reason-timeout4xi
ξ »scope-reason-token4xi
ξ »scope-reason-value-proxy4xi
ξ »scope-reason-value-test4xi

Ace XML-files
ξ »ace-all-methods4xi
ξ »ace-current-process4xi
ξ »ace-dummy-process4xi
ξ »ace-finalize4xi
ξ »ace-hello-pipe4xi
ξ »ace-hello-world4xi
ξ »ace-math-two-4xi
ξ »ace-math4xi
ξ »ace-pickle4xi
ξ »ace-pipe1-test4xi
ξ »ace-pool-one-4xi
ξ »ace-processref4xi
ξ »ace-proxy-mp-test4xi
ξ »ace-public-methods-test4xi
ξ »ace-server4xi
ξ »ace-sleep4xi
ξ »ace-sync-manager-test4xi
ξ »ace-test-after_fork4xi
ξ »ace-test-arena4xi
ξ »ace-test-ball4xi
ξ »ace-test-benchmark4xi
ξ »ace-test-constant-connection4xi
ξ »ace-test-constant-family4xi
ξ »ace-test-constant-forking4xi
ξ »ace-test-constant-heap4xi
ξ »ace-test-constant-logger4xi
ξ »ace-test-constant-managers4xi
ξ »ace-test-constant-pool4xi
ξ »ace-test-constant-process4xi
ξ »ace-test-constant-synchronize4xi
ξ »ace-test-constant-system4xi
ξ »ace-test-constant-util4xi
ξ »ace-test-cpu-corecount4xi
ξ »ace-test-format4xi
ξ »ace-test-kskeleton4xi
ξ »ace-test-locks4xi
ξ »ace-test-logger4xi
ξ »ace-test-manager4xi
ξ »ace-test-original-dir4xi
ξ »ace-test-server4xi
ξ »ace-test-shared-ctypes4xi
ξ »ace-test-skeleton-print4xi
ξ »ace-test-sphere4xi
ξ »ace-test-state4xi
ξ »ace-test-uskeleton4xi
ξ »ace-test-yskeleton4xi
ξ »ace-test-zskeleton4xi
ξ »ace-timeout4xi
ξ »ace-token4xi
ξ »ace-value-proxy4xi
ξ »ace-value-test4xi

Reason XML-files
ξ »reason-verb4xi.xml
ξ »reason-all-methods4xi
ξ »reason-current-process4xi
ξ »reason-dummy-process4xi
ξ »reason-finalize4xi
ξ »reason-hello-pipe4xi
ξ »reason-hello-world4xi
ξ »reason-math-two-4xi
ξ »reason-math4xi
ξ »reason-pickle4xi
ξ »reason-pipe1-test4xi
ξ »reason-pool-one-4xi
ξ »reason-processref4xi
ξ »reason-proxy-mp-test4xi
ξ »reason-public-methods-test4xi
ξ »reason-server4xi
ξ »reason-sleep4xi
ξ »reason-sync-manager-test4xi
ξ »reason-test-after_fork4xi
ξ »reason-test-arena4xi
ξ »reason-test-ball4xi
ξ »reason-test-benchmark4xi
ξ »reason-test-constant-connection4xi
ξ »reason-test-constant-family4xi
ξ »reason-test-constant-forking4xi
ξ »reason-test-constant-heap4xi
ξ »reason-test-constant-logger4xi
ξ »reason-test-constant-managers4xi
ξ »reason-test-constant-pool4xi
ξ »reason-test-constant-process4xi
ξ »reason-test-constant-synchronize4xi
ξ »reason-test-constant-system4xi
ξ »reason-test-constant-util4xi
ξ »reason-test-cpu-corecount4xi
ξ »reason-test-format4xi
ξ »reason-test-kskeleton4xi
ξ »reason-test-locks4xi
ξ »reason-test-logger4xi
ξ »reason-test-manager4xi
ξ »reason-test-original-dir4xi
ξ »reason-test-server4xi
ξ »reason-test-shared-ctypes4xi
ξ »reason-test-skeleton-print4xi
ξ »reason-test-sphere4xi
ξ »reason-test-state4xi
ξ »reason-test-uskeleton4xi
ξ »reason-test-yskeleton4xi
ξ »reason-test-zskeleton4xi
ξ »reason-timeout4xi
ξ »reason-token4xi
ξ »reason-value-proxy4xi
ξ »reason-value-test4xi

Sense XML-files
ξ »sense-all-methods4xi
ξ »sense-current-process4xi
ξ »sense-dummy-process4xi
ξ »sense-finalize4xi
ξ »sense-hello-pipe4xi
ξ »sense-hello-world4xi
ξ »sense-math-two-4xi
ξ »sense-math4xi
ξ »sense-pickle4xi
ξ »sense-pipe1-test4xi
ξ »sense-pool-one-4xi
ξ »sense-processref4xi
ξ »sense-proxy-mp-test4xi
ξ »sense-public-methods-test4xi
ξ »sense-server4xi
ξ »sense-sleep4xi
ξ »sense-sync-manager-test4xi
ξ »sense-test-after_fork4xi
ξ »sense-test-arena4xi
ξ »sense-test-ball4xi
ξ »sense-test-benchmark4xi
ξ »sense-test-constant-connection4xi
ξ »sense-test-constant-family4xi
ξ »sense-test-constant-forking4xi
ξ »sense-test-constant-heap4xi
ξ »sense-test-constant-logger4xi
ξ »sense-test-constant-managers4xi
ξ »sense-test-constant-pool4xi
ξ »sense-test-constant-process4xi
ξ »sense-test-constant-synchronize4xi
ξ »sense-test-constant-system4xi
ξ »sense-test-constant-util4xi
ξ »sense-test-cpu-corecount4xi
ξ »sense-test-format4xi
ξ »sense-test-kskeleton4xi
ξ »sense-test-locks4xi
ξ »sense-test-logger4xi
ξ »sense-test-manager4xi
ξ »sense-test-original-dir4xi
ξ »sense-test-server4xi
ξ »sense-test-shared-ctypes4xi
ξ »sense-test-skeleton-print4xi
ξ »sense-test-sphere4xi
ξ »sense-test-state4xi
ξ »sense-test-uskeleton4xi
ξ »sense-test-yskeleton4xi
ξ »sense-test-zskeleton4xi
ξ »sense-timeout4xi
ξ »sense-token4xi
ξ »sense-value-proxy4xi
ξ »sense-value-test4xi

select: ~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~Zapped Programs

Sense Zapped Multiprocessing4xi Programs
ξ note: some may be missing!
ξ »sense_all_methods4xi_zap.py
ξ »sense_ctypes4xi_zap.py
ξ »sense_current_process4xi_zap.py
ξ »sense_dummy_process4xi_zap.py
ξ »sense_finalize4xi_zap.py
ξ »sense_hello_pipe4xi_zap.py
ξ »sense_hello_world4xi_zap.py
ξ »sense_math4xi_zap.py
ξ »sense_pickle4xi_zap.py
ξ »sense_pipe1_test4xi_zap.py
ξ »sense_pool_one_4xi_zap.py
ξ »sense_processref4xi_zap.py
ξ »sense_proxy_mp_test4xi_zap.py
ξ »sense_public_methods_test4xi_zap.py
ξ »sense_sync_manager_test4xi_zap.py
ξ »sense_test_after_fork4xi_zap.py
ξ »sense_test_arena4xi_zap.py
ξ »sense_test_constant_connection4xi_zap.py
ξ »sense_test_constant_family4xi_zap.py
ξ »sense_test_constant_forking4xi_zap.py
ξ »sense_test_constant_heap4xi_zap.py
ξ »sense_test_constant_logger4xi_zap.py
ξ »sense_test_constant_managers4xi_zap.py
ξ »sense_test_constant_pool4xi_zap.py
ξ »sense_test_constant_process4xi_zap.py
ξ »sense_test_constant_synchronize4xi_zap.p
ξ »sense_test_constant_system4xi_zap.py
ξ »sense_test_constant_util4xi_zap.py
ξ »sense_test_cpu_corecount4xi_zap.py
ξ »sense_test_format4xi_zap.py
ξ »sense_test_kskeleton4xi_zap.py
ξ »sense_test_logger4xi_zap.py
ξ »sense_test_manager4xi_zap.py
ξ »sense_test_original_dir4xi_zap.py
ξ »sense_test_server4xi_zap.py
ξ »sense_test_shared_ctypes4xi_zap.py
ξ »sense_test_skeleton_print4xi_zap.py
ξ »sense_test_sphere4xi_zap.py
ξ »sense_test_state4xi_zap.py
ξ »sense_test_uskeleton4xi_zap.py
ξ »sense_test_yskeleton4xi_zap.py
ξ »sense_test_zskeleton4xi_zap.py
ξ »sense_value_proxy4xi_zap.py
ξ »sense_value_test4xi_zap.py

Reason Zapped Multiprocessing4xi Programs
ξ note: some may be missing!
ξ »reason_all_methods4xi_zap.py
ξ »reason_ctypes4xi_zap.py
ξ »reason_current_process4xi_zap.py
ξ »reason_dummy_process4xi_zap.py
ξ »reason_finalize4xi_zap.py
ξ »reason_hello_pipe4xi_zap.py
ξ »reason_hello_world4xi_zap.py
ξ »reason_math4xi_zap.py
ξ »reason_pickle4xi_zap.py
ξ »reason_pipe1_test4xi_zap.py
ξ »reason_pool_one_4xi_zap.py
ξ »reason_processref4xi_zap.py
ξ »reason_proxy_mp_test4xi_zap.py
ξ »reason_public_methods_test4xi_zap.py
ξ »reason_sync_manager_test4xi_zap.py
ξ »reason_test_after_fork4xi_zap.py
ξ »reason_test_arena4xi_zap.py
ξ »reason_test_constant_connection4xi_zap.py
ξ »reason_test_constant_family4xi_zap.py
ξ »reason_test_constant_forking4xi_zap.py
ξ »reason_test_constant_heap4xi_zap.py
ξ »reason_test_constant_logger4xi_zap.py
ξ »reason_test_constant_managers4xi_zap.py
ξ »reason_test_constant_pool4xi_zap.py
ξ »reason_test_constant_process4xi_zap.py
ξ »reason_test_constant_synchronize4xi_zap.p
ξ »reason_test_constant_system4xi_zap.py
ξ »reason_test_constant_util4xi_zap.py
ξ »reason_test_cpu_corecount4xi_zap.py
ξ »reason_test_format4xi_zap.py
ξ »reason_test_kskeleton4xi_zap.py
ξ »reason_test_logger4xi_zap.py
ξ »reason_test_manager4xi_zap.py
ξ »reason_test_original_dir4xi_zap.py
ξ »reason_test_server4xi_zap.py
ξ »reason_test_shared_ctypes4xi_zap.py
ξ »reason_test_skeleton_print4xi_zap.py
ξ »reason_test_sphere4xi_zap.py
ξ »reason_test_state4xi_zap.py
ξ »reason_test_uskeleton4xi_zap.py
ξ »reason_test_yskeleton4xi_zap.py
ξ »reason_test_zskeleton4xi_zap.py
ξ »reason_timeout4xi_zap.py
ξ »reason_value_proxy4xi_zap.py
ξ »reason_value_test4xi_zap.py

Ace Zapped Multiprocessing4xi Programs
ξ note: some may be missing!
ξ »ace_all_methods4xi_zap.py
ξ »ace_ctypes4xi_zap.py
ξ »ace_current_process4xi_zap.py
ξ »ace_dummy_process4xi_zap.py
ξ »ace_finalize4xi_zap.py
ξ »ace_hello_pipe4xi_zap.py
ξ »ace_hello_world4xi_zap.py
ξ »ace_math4xi_zap.py
ξ »ace_pickle4xi_zap.py
ξ »ace_pipe1_test4xi_zap.py
ξ »ace_pool_one_4xi_zap.py
ξ »ace_processref4xi_zap.py
ξ »ace_proxy_mp_test4xi_zap.py
ξ »ace_public_methods_test4xi_zap.py
ξ »ace_sleep4xi_zap.py
ξ »ace_sync_manager_test4xi_zap.py
ξ »ace_test_after_fork4xi_zap.py
ξ »ace_test_arena4xi_zap.py
ξ »ace_test_constant_connection4xi_zap.py
ξ »ace_test_constant_family4xi_zap.py
ξ »ace_test_constant_forking4xi_zap.py
ξ »ace_test_constant_heap4xi_zap.py
ξ »ace_test_constant_logger4xi_zap.py
ξ »ace_test_constant_managers4xi_zap.py
ξ »ace_test_constant_pool4xi_zap.py
ξ »ace_test_constant_process4xi_zap.py
ξ »ace_test_constant_synchronize4xi_zap.p
ξ »ace_test_constant_system4xi_zap.py
ξ »ace_test_constant_util4xi_zap.py
ξ »ace_test_cpu_corecount4xi_zap.py
ξ »ace_test_format4xi_zap.py
ξ »ace_test_kskeleton4xi_zap.py
ξ »ace_test_logger4xi_zap.py
ξ »ace_test_manager4xi_zap.py
ξ »ace_test_original_dir4xi_zap.py
ξ »ace_test_server4xi_zap.py
ξ »ace_test_shared_ctypes4xi_zap.py
ξ »ace_test_skeleton_print4xi_zap.py
ξ »ace_test_sphere4xi_zap.py
ξ »ace_test_state4xi_zap.py
ξ »ace_test_uskeleton4xi_zap.py
ξ »ace_test_yskeleton4xi_zap.py
ξ »ace_test_zskeleton4xi_zap.py
ξ »ace_timeout4xi_zap.py
ξ »ace_value_proxy4xi_zap.py
ξ »ace_value_test4xi_zap.py

select: ~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~Deployment to Scope4Xi

Previous Steps before Deploying to Scope4Xi

»Fetching Image Programs to Studio
ξ all image modules

»Generating Image Programs for Devices
ξ has used as its input folder L:\job\041721\studio4xi\cc\generate
ξ has generated code to devices using as its input file 2D image module for virtual device i.e. L:\job\041721\studio4xi\cc\generate\in\lib\dragon\dragon2image4xi.py

Image2D Module Deployment

Input Folder for Deployment
ξ L:\job\041721\studio4xi\cc\generate\out\lib

Destination Folder
ξ E:\Scope4xi\041721\zap\lib
ξ has also subfolder dragon which does and should NOT get updated !

Deployment
ξ *** warning *** do NOT deploy to the module having been used to produce dragon module - for example apu2image4xi.py was input to dragon2image4xi.py !!
ξ *** warning *** take backups such as scope4xi before updating it!
ξ use explorer, do NOT use command mode!
ξ deploy first ONLY one for example L:\backup2E\Scope4xi\041721\zap\lib\z\zpu2image4xi.py -- > E:\Scope4xi\041721\zap\lib\z\zpu2image4xi.py
ξ FIRST = a = APU might be good as master for dragon2image4xi.py
ξ LAST = z = ZPU might be good to test whether generated module gets compiled ok !

Test
ξ >> go2scope (in command mode)
ξ edit (if necessary batch files for devices)
ξ >> all2c (compile all) or c2a (compile device a modules)

Recovery
ξ L:\backup2E\Scope4xi\041721\zap\lib\a\apu2image4xi.py -- > E:\Scope4xi\041721\zap\lib\a\apu2image4xi.py
ξ original source to produce dragon2image4xi.py
ξ c2a (compile device a modules)

Edit
ξ L:\job\041721\studio4xi\cc\generate\in\lib\dragon\dragon2image4xi.py
ξ cut too long comment lines !
ξ change dragonized texts to modernized

Next Step

ξ go2scope and all2c (compile all)!

select: ~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~ALL dragonized modules

Dummy sub-package

»__init__

To be dragonized
ξ 'Process', 'current_process', 'active_children', 'freeze_support',
ξ self._parent = current_process()
ξ assert self._parent is current_process()
ξ current_process = threading.current_thread
ξ current_process()._children = weakref.WeakKeyDictionary()
ξ children = current_process()._children

»dummy connection

Multiprocessing Package
»__init__
ξ Module initializing the software package

»connection
ξ Module in a higher level for using sockets (or Windows named pipes)

To be dragonized
ξ global xmlrpclib
ξ class XmlListener(Listener): def accept(self): global xmlrpclib => module xmllistener4xi.py and the class XmlListener4Xi is the logical place
ξ return xmlrpclib.dumps((obj,), None, None, None, 1).encode('utf8')
ξ (obj,), method = xmlrpclib.loads(s.decode('utf8'))
ξ import xmlrpc.client as xmlrpclib
ξ 'xmlrpclib' : (connection.XmlListener, connection.XmlClient)
ξ »dragonized #059

»forking
ξ Module for starting a process object using os.fork() or CreateProcess()

To be dragonized
ξ global _python_exe
ξ return xmlrpclib.dumps((obj,), None, None, None, 1).encode('utf8')
ξ »dragonized #063

»heap
ξ Module supportting allocation of memory from an mmap
ξ »dragonized #064

»managers
ξ Module providing the `SyncManager` class for dealing with shared objects

To be dragonized
ξ 'xmlrpclib' : (connection.XmlListener, connection.XmlClient)
ξ »dragonized #062

»pool
ξ Module providing the `Pool` class for managing a process pool
ξ »dragonized #065

»process
ξ Module providing `Process` class which emulates `threading.Thread`

To be dragonized
ξ global _current_process;
ξ _current_process = self
ξ »dragonized #061

»queues
ξ Module implementing queues
ξ »dragonized #066

»reduction
ξ Module to allow connection and socket objects to be transferred between processes

To be dragonized
ξ global _lock, _listener, _cache
ξ »dragonized #067

»sharedctypes
ξ Module which supports allocation of ctypes objects from shared memory
ξ »dragonized #068

»synchronize
ξ Module implementing synchronization primitives such as semaphores, locks, condition, event
ξ »dragonized #060

»util
ξ Module providing various facilities to other parts of the package

To be dragonized
ξ global _log_to_stderr
ξ global _logger; _logger = logging.getLogger(LOGGER_NAME)
ξ global _log_to_stderr
ξ global _exiting
ξ »dragonized #069

select: ~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~WEB4Xi

Scope4Xi
ξ scoping of OpenCL using multiprocessing4xi and studio4xi services »Scope4Xi

Multiprocessing4Xi
ξ multiprocessing services with dragonized trace »Multiprocessing4Xi

select: ~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~Ctypes and Multiprocessing

»Ctypes and Multiprocessing
ξ C-language types such as arrays and structures
ξ classes for 2d and 3d coordinated for shared memory

»#058 Test with dragonized multiprocessing modules

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~Proxy Objects in Multiprocessing

»Proxy Objects in Multiprocessing

»#050 Test with dragonized multiprocessing modules

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~Benchmarks in Multiprocessing

»Benchmarks in Multiprocessing
# ######## testing queue.Queue
# 32768 objects passed through the queue in 1.05798908 seconds
# average number/sec: 30971.9642853
#
# ######## testing multiprocessing.Queue
#
# 65536 objects passed through the queue in 1.8677286 seconds
# average number/sec: 35088.6097691 <--- + 13.3% faster queue processing with multiprocessing compared to standard Queue

# ######## testing threading.Condition
#
# 32768 waits in 1.38062652 seconds
# average number/sec: 23734.1522311
#
# ######## testing multiprocessing.Condition
#
# 65536 waits in 1.97240404 seconds
# average number/sec: 33226.458003 <--- +40 % faster condition with multiprocessing compared to threading
#

»#049 Test with dragonized multiprocessing modules

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~Server with Pool Workers in Multiprocessing

»Server with Pool Workers in Multiprocessing
ξ *** errors *** in pickling (multiprocessing required pickable objects); hte original example might conttain bugs

»Tests with dragonized multiprocessing modules

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~Calculating with Pool of Workers in Multiprocessing

»Calculating with Pool of Workers in Multiprocessing
»Calculating with Pool of Workers in Multiprocessing - Example 2

»#052 Tests with dragonized multiprocessing modules

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~Locks and Semaphores in Multitasking

»Locks and Semaphores in Multitasking
ξ uses semaphores and locks
ξ tests subprocesses, waits processes to finish

»#045 = Tests with dragonized multiprocessing modules

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~Server with Pool Workers TEST

»Server with Pool Workers TEST in Multiprocessing
ξ *** errors *** in pickling (multiprocessing required pickable objects); note that the original example might contain bugs

»Tests with dragonized multiprocessing modules

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~Constants4Xi

Constants4Xi tests

»test_logger4xi *** logger itself ***
ξ tests all functions
ξ tests the class methods results being comparable to those when functions are being used
Affected modules:
ξ logger4xi.py <-- see logging in Python manual
ξ *** warning *** leave this last because it affects almost EVERY module !!!

»test_original_dir4xi.py Δ Δ Δ
Affected modules:
ξ original_dir4xi.py

»test_constant_family4xi Δ Δ Δ
Affected modules:
ξ constant_family4xi.py
ξ address_type4xi.py
ξ arbitrary_address4xi.py
ξ arena4xi.py
ξ client4xi.py
ξ client4xi.py
ξ connectionwrapper4xi.py
ξ heap4xi.py
ξ listener4xi.py
ξ pipe4xi.py
ξ pipeclient4xi.py
ξ pipelistener4xi.py
ξ socketclient4xi.py
ξ socketlistener4xi.py
ξ xmllistener4xi.py

»test_constant_connection4xi <--- BUFSIZE missing
Affected modules:
ξ constant_connection4xi.py
ξ answer_challenge4xi.py
ξ arbitrary_address4xi.py
ξ arena4xi.py
ξ pipelistener4xi.py
ξ socketlistener4xi.py
ξ listener4xi.py
ξ connectionwrapper4xi.py
ξ xmllistener4xi.py
ξ pipe4xi.py
ξ deliver_challenge4xi.py
ξ _xml_dumps4xi.py
ξ _xml_loads4xi.py
ξ xmlclient4xi.py
ξ heap4xi.py
ξ applyresult4xi.py
ξ boundedsemaphore4xi.py
ξ condition4xi.py
ξ event4xi.py
ξ imapiterator4xi.py
ξ lock4xi.py
ξ pool4xi.py
ξ queue4xi.py
ξ rlock4xi.py
ξ semaphore4xi.py
ξ semlock4xi.py
ξ socketlistener4xi.py
ξ imapunorderediterator4xi.py
ξ mapresult4xi.py
ξ threadpool4xi.py
ξ _xml_loads4xi.py

»test_constant_heap4xi Δ Δ Δ
ξ constant_heap4xi.py
Affected modules:

»test_constant_managers4xi Δ Δ Δ
ξ constant_managers4xi.py
Affected modules:
ξ basemanager4xi.py
ξ baseproxy4xi.py
ξ convert_to_error4xi.py
ξ dispatch4xi.py
ξ eventproxy4xi.py
ξ server4xi.py
ξ state4xi.py
ξ token4xi.py
ξ syncmanager4xi.py

»test_constant_pool4xi Δ Δ Δ
»constant_pool4xi
Affected modules:
ξ constant_synchronize4xi.py
ξ pool4xi.py

»test_constant_process4xi Δ Δ Δ
»constant_process4xi
Affected modules:
ξ process4xi.py
ξ terminate4xi.py

»test_constant_synchronize4xi Δ Δ Δ
»constant_synchronize4xi
Affected modules:
ξ synchronize.py
ξ constant_logger4xi.py
ξ lock4xi.py
ξ boundedsemaphore4xi.py
ξ rlock4xi.py
ξ semaphore4xi.py

»test_constant_system4xi Δ Δ Δ
»constant_system4xi
Affected modules:
ξ arena4xi.py
ξ connectionwrapper4xi.py
ξ constant_family4xi.py
ξ constant_forking4xi.py
ξ constant_util4xi.py
ξ cpu_corecount4xi.py
ξ listener4xi.py
ξ popen4xi.py
ξ pipe4xi.py
ξ pipeclient4xi.py
ξ pipelistener4xi.py
ξ queue4xi.py
ξ semlock4xi.py
ξ send_handle4xi.py
ξ simplequeue4xi.py
ξ xmllistener4xi.py
ξ listener4xi.py
ξ socketlistener4xi.py
ξ heap4xi.py

»test_constant_util4xi Δ Δ Δ
»constant_util4xi
ξ #from debug4xi import debug4xi <--- FORBIDDEN, causes SERIOUS PROBLEM !
ξ #from sub_debug4xi import sub_debug4xi <--- FORBIDDEN, causes SERIOUS PROBLEM !
ξ # test_constant_util4xi.py is used to test this module !
Affected modules:
ξ logger4xi.py
ξ debug4xi.py <--- see above
ξ sub_debug4xi.py <--- see above

Constants4Xi to be FURTHER dragonized

»constant_logger4xi Δ Δ Δ
ξ functions to handdle the object
ξ ConstantLogger4xi offers as methods the services provided by corresponding function (actually calls them)
ξ thereby a more object-oriented approach can be achieved
»logger4xi Δ Δ Δ
»original_dir4xi.py Δ Δ Δ

»constant_family4xi
»constant_connection4xi
»constant_heap4xi
»constant_managers4xi
»constant_pool4xi
»constant_process4xi
»constant_synchronize4xi
»constant_system4xi
»constant_util4xi

*** How to handle properly variables ***
ξ they MUST be initialized for the Python compiler !!!
ξ this forces you to set global values outside functions and class methods
ξ because import module statement initializes it also hides settings
ξ therefore you should let functions of ONE module to initialize and change global variables
ξ THE ONLY RIGHT MODULE TO HANDLE AND MANAGER A GLOBAL VARIABLE IS THE ONE WHICH DEFINES IT
ξ ONLY functions which are defined in the same module where a global variale is should manipulate it
ξ otherwise you might end up having SEVERAL global variables which are global only inside one module, NOT in the systems
ξ define a variable global in ONE module
ξ and ONLY in THAT module define fucntion operating with that varaible
ξ define also a Class in the same module and let class methods to call those functions (keep method names unique)
ξ for compability reasons a separate function in a different method might have a function which originally
ξ modified a global variable; that function now uses the class defined in that RIGHT module

Notes:
ξ review original multiprocessing modules and compare to above and new modules
ξ use find4xi.py to check how global objects are being defined and used to find possible bugs
ξ a constant might be actually a variable in the original multiprocessing !
ξ using classes and their objects you only have to import the class instead of several functions !
ξ when using classes take care of how object is created so that __init__ will not change values

Modules used for above
»connection.py
»connection
»heap
»managers
»pool
»process
»synchronize
»connection
»util

Other Modules used
»time4xi
»test_time4xi

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~Managers module DRAGONIZED TEST

Testing dragonized managers.py ( Δ = done)
»test_managers.py Δ
ξ converted from managers.py
ξ defines new dragonized classes, functions and types

manager4xi.py Δ
ξ the new main module created from multiprocessing __init__.py
ξ ---------------------------------------------------------------------------------------------
ξ Solution
ξ + is compatible with the common multiprocessing
ξ - new dragonized proxies and type are not registered
ξ ---------------------------------------------------------------------------------------------
ξ The code is separated to this module.
ξ The original Manager function in ___init__.py is called
ξ SyncManager class
ξ
ξ called when the multiprocessing package is initialized
ξ __init__.py:
ξ
ξ def Manager():
ξ from multiprocessing.managers import SyncManager <--- uses managers.py class SyncManager
ξ m = SyncManager()
ξ m.start()
ξ ---------------------------------------------------------------------------------------------
ξ return Manager()

Notes:
ξ proxies and types got registered in the above process by managers.py (yes, although SyncManager register calls are not intended !

»test_manager1_mp_xi2.py
ξ the first trial with the manager2xi module using both common and dragonized multiprocessing #048
ξ manager2xi = Manager4Xi() <--- uses the new dragonized layer which is compatible ==> it does NOT register new proxies, types...
ξ manager = Manager() <--- uses the standard multiprocessing

»test_manager4xi.py Δ
ξ uses function sense, reason and ace for multiprocessing
ξ creates three queues and three pipes with consumer and publisher ends
ξ creates three locks
ξ creates three dictionaries using each manager
ξ create three lists using each manager
ξ creates three managers each handling one list and dictionary for three processes
ξ creates an object process such as process2xi with function sense,
ξ which puts data to process2xi's queue and sends data to process pipe using dict2xi and list2xi,
ξ which are managed by manager2xi object
ξ see the module's output embedded inside test_manager1_mp_xi2.py

Testing New Modules from managers.py defining Classes Δ (*** 24 ***)
01) Token4Xi »test_token4xi.py Δ
02) RemoteError4Xi »test_remoteerror4xi.py Δ
03) Server4Xi »test_server4xi.py Δ
04) State4Xi »test_state4xi.py Δ
05) BaseManager4Xi »test_basemanager4xi.py Δ
ξ note: this class does NOT define any methods but its base class methods are being used
06) ProcessLocalSet4Xi »test_processlocalset4xi.py Δ
07) BaseProxy4Xi »test_baseproxy4xi.py - preliminary test skeleton done
11) Namespace4Xi »test_namespace4xi.py Δ
12) Value4Xi »test_value4xi.py Δ
14) IteratorProxy4Xi »test_iteratorproxy4xi.py Δ
15) AcquirerProxy4Xi »test_acquirerproxy4xi.py Δ
16) ConditionProxy4Xi »test_conditionproxy4xi.py Δ
17) NamespaceProxy2xi »test_namespaceproxy4xi.py Δ
18) ValueProxy4Xi »test_valueproxy4xi.py Δ
20) ListProxy4Xi »test_listproxy4xi.py (list2xi2.py to be created, uses standard list now) Δ
24) SyncManager4Xi »test_syncmanager4xi.py <--- continue in test function by calling start
25) EventProxy4Xi »test_eventproxy4xi.py (event4xi.py to be created, uses threading event not) Δ

Testing New Modules from managers.py defining Functions Δ
08) »test_rebuildproxy4xi.py; RebuildProxy4Xi Δ
09) »test_makeproxytype4xi.py; MakeProxyType4Xi Δ
10) »test_autoproxy4xi.py; AutoProxy4Xi Δ
13) »test_array4xi.py; Array4Xi Δ

Testing New Modules from managers.py defining Types Δ
19) »test_baselistproxy4xi.py Δ
21) »test_dictproxy4xi.py Δ
22) »test_arrayproxy4xi.py Δ
23) »test_poolproxy4xi.py Δ
34) »test_listener_client4xi.py Δ

Notes:
ξ manager2xi = Manager4Xi() <--- uses the new dragonized layer which is compatible ==> it does NOT register new types
ξ because standard multiprocessing types got registered you do NOT define them anymore in these new type modules !

ξ Manager4Xi in manager4xi.py calls __init__.py modules Manager function
ξ __init__.py
ξ def Manager():
ξ '''
ξ Returns a manager associated with a running server process
ξ
ξ The managers methods such as `Lock()`, `Condition()` and `Queue()`
ξ can be used to create shared objects.
ξ '''
ξ from multiprocessing.managers import SyncManager
ξ m = SyncManager()
ξ m.start()
ξ return m
ξ managers.py
ξ class SyncManager(BaseManager):
ξ here exists registration code but is it executed ?

Testing New Modules from managers.py defining functions Δ (*34*)
27) »test_reduce_array4xi.py; reduce_array2xi Δ
28) »test_rebuild_as_list4xi.py; rebuild_as_list2xi Δ
29) »test_pickle4xi.py; pickle2xi Δ
30) »test_dispatch4xi.py; dispatch2xi Δ
31) »test_convert_to_error4xi.py; convert_to_error2xi Δ
32) »test_all_methods4xi.py; all_methods2xi (includes useful examples for Process4Xi) Δ
33) »test_public_methods4xi.py; public_methods2xi Δ
34) »test_debug_info4xi.py; debug_info *** needs to provide more information ***

Changes to other modules
35) »forkingpickler4xi.py
36) »rebuild_as_list4xi.py
37) »dispatch4xi.py
38) »remoteerror4xi.py
39) »convert_to_error4xi.py
40) »all_methods4xi.py
41) »public_methods4xi.py
42) »server4xi.py
43) »processlocalset4xi.py
44) »rebuildproxy4xi.py
45) »makeproxytype4xi.py
46) »autoproxy4xi.py
47) »namespace4xi.py
48) »value4xi.py
49) »iteratorproxy4xi.py
50) »acquirerproxy4xi.py
51) »conditionproxy4xi.py
52) »eventproxy4xi.py
53) »namespaceproxy.py
54) »valueproxy4xi.py
55) »syncmanager4xi.py !!! DEMANDING CHANGE !!!

Related Manager tests
48) »#048
51) »#051

New Modules created
90) »time4xi.py
91) »test_time4xi.py
92) »date4xi.py
93) »test_date4xi.py

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~__init__ DRAGONIZED

»__init__.py
ξ initializes the multiprocessing package
ξ import statements for each class
ξ Python documentation statements for each class
ξ note: you do NOT create new modules for classes such as as Pipe (Pipe4Xi created from managers.py)
ξ i.e. only those new modules created which can't be created from other modules

To be dragonized
ξ 'Process', 'current_process', 'active_children', 'freeze_support',
ξ from multiprocessing.process import Process, current_process, active_children

DragonXi2 modules
»manager2xi
»ProcessError4Xi
»BufferTooShort4Xi
»TimeoutError4Xi
»Authentication4Xi

DragonXi4 modules
»manager4xi
»ProcessError4Xi
»BufferTooShort4Xi
»TimeoutError4Xi
»Authentication4Xi

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~Multicore CPU TEST

»cpu_corecount4xi.py

ξ count2core4xi.bat

»cpu_corecount4xi.py

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~Locks and Semaphores TEST

»test_locks_mp_xi2.py
ξ namespace is a challenge; the same namespace with multiprocessing set
ξ this module has MANY excellent tests forr multiprocessing as a whole !

modified modules
»semaphore4xi.py
»valuefunction4xi.py
»synchronized_function4xi.py

Notesξ compilation phase does NOT reveal enough errors
ξ therefore testing with many modules is necessary
ξ all other tests passed ok after testing this module .i.e. no errors were generated to other modules

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~Process Reference TEST

»test_processref_mp_xi2.py
ξ with Process4Xi, Queue4Xi, Pipe4Xi, Lock4Xi, Manager4Xi, Pool4Xi

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~Pool of workers TEST

Pool of workers TEST with Pool4Xi
»test_pool1_mp_xi2.py
ξ timeouts with phase(2)

Changes
»Pool4Xi class in pool4xi.py
ξ apply_async method

Analyzed
»applyresult4xi.py
»Pool class in pool.py
ξ apply_async method changed by using pool.py

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~Manager TEST with Manager4Xi

»test_manager1_mp_xi2.py with Process4Xi, Queue4Xi, Pipe4Xi, Lock4Xi and Manager4Xi
ξ varied the manager used i.e. manager2xi = Manager() or Manager4Xi() in Phase III

Tests
»Manager4Xi in manager4xi.py
ξ m = SyncManager4Xi() and m = SyncManager()
ξ return Manager() <--- this would call original function in __init__.py

Changes
»Manager4Xi in manager4xi.py

@property
def name(self):
#return Process.name(self) # property object is not callable!
#therefore we must copy the code from the original module
return self._name

ξ created from »__init__.py

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~Benchmarks TEST

»test_benchmark_mp_xi2.py TEST
ξ benchmark results are embedded inside the module
ξ speed with dragonized modules is ok compared to the speed when standard multiprocessing modules are being used
ξ threading might be in some cases faster

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~Proxy Objects TEST

»test_proxy_mp_xi4.py with Process4Xi, Queue4Xi, Pipe4Xi, Lock4Xi and Manager4Xi
ξ test_proxy_mp_xi4.txt
ξ { Pipe4Xi : Pipe4Xi ; Step 6/8d error was win32.ERROR_PIPE_CONNECTED = 535; time: 12:51:06 06/18/09 FLE Daylight Time}

Updated modules:
»listener4xi.py
ξ address2xi = address or arbitrary_address4xi(family)
»arbitrary_address4xi.py
ξ uses get_temp_dir4xi now

»test_proxy_mp_xi2.py with Process4Xi, Queue4Xi, Pipe4Xi, Lock4Xi and Manager4Xi
ξ example output: dict2xi Presentation: DictProxy object, typeid 'dict' at 0x3457a90 <--- shows the memory address of the referent diplayed by this proxy
ξ a proxy is an object which refers to a shared object which lives (presumably) in a different process
ξ the shared object is said to be the referent of the proxy
ξ multiple proxy objects may have the same referent
ξ proxy: prints presentation <--- OK
ξ proxy: return the representation of the referent <--- OK
ξ increasing timeouts in test_proxy_mp_xi2.py for applyresult4xi.py module's get method helped to get results!
ξ succesfull test_all.bat <=> old tests and modules passed OK!
ξ this module SENSE

Changes to modules
»applyresult4xi.py

Changes to Modules from managers.py defining Classes (*)
01) Token4Xi »token4xi.py
02) RemoteError4Xi »remoteerror4xi.py
03) Server4Xi »server4xi.py
04) State4Xi »state4xi.py
05) BaseManager4Xi »basemanager4xi.py
06) ProcessLocalSet4Xi »processlocalset4xi.py
07) BaseProxy4Xi »baseproxy4xi.py (*)
11) Namespace4Xi »namespace4xi.py
12) Value4Xi »value4xi.py
14) IteratorProxy4Xi »iteratorproxy4xi.py
15) AcquirerProxy4Xi »acquirerproxy4xi.py
16) ConditionProxy4Xi »conditionproxy4xi.py
17) NamespaceProxy2xi »namespaceproxy4xi.py
18) ValueProxy4Xi »valueproxy4xi.py
20) ListProxy4Xi »listproxy4xi.py (*)
24) SyncManager4Xi »syncmanager4xi.py
25) EventProxy4Xi »eventproxy4xi.py

Changes to Modules from managers.py defining Functions
08) »rebuildproxy4xi.py; RebuildProxy4Xi (*)
09) »makeproxytype4xi.py; MakeProxyType4Xi
10) »autoproxy4xi.py; AutoProxy4Xi
13) »array4xi.py; Array4Xi

Changes to Modules from managers.py defining Types
19) »baselistproxy4xi.py; BaseListProxy and BaseListProxy4Xi
21) »dictproxy4xi.py; DictProxy and DictProxy4Xi
22) »arrayproxy4xi.py; ArrayProxy and ArrayProxy4Xi
23) »poolproxy4xi.py; PoolProxy and PoolProxy4Xi
34) »listener_client4xi.py; listener_client2xi

Changes to Modules from managers.py defining functions
27) »reduce_array4xi.py; reduce_array2xi
28) »rebuild_as_list4xi.py; rebuild_as_list2xi
29) »pickle4xi.py; pickle2xi (no function available but just code)
30) »dispatch4xi.py; dispatch2xi
31) »convert_to_error4xi.py; convert_to_error2xi
32) »all_methods4xi.py; all_methods2xi
33) »public_methods4xi.py; public_methods2xi
33) »debug_info4xi.py; debug_info

Changes to Modules defining Classes from forking.py
01) ForkingPickler4Xi »forkingpickler4xi.py
02) _C2xi »_c4xi.py
03) Popen2xi »popen4xi.py

Changes to Modules defining Funtions from forking.py
04) assert_spawning2xi »assert_spawning4xi.py
05) _reduce_method2xi »_reduce_method4xi.py
06) _reduce_method_descriptor2xi »_reduce_method_descriptor4xi.py
07) _reduce_partial2xi »_reduce_partial4xi.py
08) dump2xi »dump4xi.py
09) duplicate2xi »duplicate4xi.py
10) is_forking2xi »is_forking4xi.py
11) get_command_line2xi »get_command_line4xi.py
11) get_preparation_data2xi »get_preparation_data4xi.py
12) prepare2xi »prepare4xi.py

Analyzed modules
»__init__.py
»managers.py
»forking.py

Dragonized modules
»managers.py #062
»forking.py #063

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~Customized Manager and Proxies TEST

»test_custom_mp_xi2.py
ξ object manager2xi created from MyManager4Xi
ξ class registered with name DragonXi1 is used
ξ class registered with name DragonXi2 is used
ξ function registered with name sense2xi is called
ξ operator registered with name operator2xi and it's operations are used

Changes to modules:
»basemanager4xi.py
ξ this class in inherited from BaseManager
ξ it does NOT define its own methods but uses BaseManager methods
ξ the reason for this is that Basemanager methods may return with certain parameters and sometimes not
ξ due to the above the module basemanager2xi would pass a wrong number of arguments to BaseManager methods

»baseproxy4xi.py
ξ _callmethod: raise convert_to_error2xi(kind, result)

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~ Calculating with Pool of Workers TEST

»Calculating with Pool of Workers TEST 1
ξ ok
»Calculating with Pool of Workers TEST 2
ξ ok

New Modules
»terminate4xi.py

Modules of Multiprocessing needing investigation
»pool.py
»util.py

Modules modified
»pool4xi.py

Modules related to this test
ξ those splitted from util.py »#069

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~ Test All Methods4Xi

»test_all_methods4xi.py
ξ some proxies embed MakeProxyType4Xi function so that ForkingPickler4Xi finds them in the right module
ξ this was the firt module to use the new Print4Xi to get the trace for this module!
ξ forkingpickler4xi.py now embeds Python pickler code so that it could be verified why pickling of proxy modules failed
ξ to be solved; see below i.e. this test has NOT yet passed !

Modules in tests
»syncmanager4xi.py
»constant_connection4xi.py
ξ buffer size increased to 1048576 from 256/8192 <-- maybe too high !

»popen4xi
{ Popen4Xi : __init__ ; Step 4/8b: to be solved: *** OS error 9: bad file descriptor *** ; time: 10:02:27 06/18/09 FLE Daylight Time}
ξ this seems to be bug issue in Python and Windows !!!!

»process4xi
»pipe4xi
»print4xi
ξ provides possibility to set trace to the modules you want to debug!
»print4xi
»poolproxy4xi.py
»dictproxy4xi.py
»baselistproxy4xi.py
»arrayproxy4xi.py

To be solved
»syncmanager4xi.py
ξ self._address = reader2xi.recv() <-- EOF !

Test Log
»test_all_methods4xi.txt

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~ Connection dummy in multiprocessing2xi

»Connection dummy in multiprocessing2xi
ξ Listener, Client, Pipe, Connection
ξ only compilation of the program, which was copied from multiprocessing package to be commented and modified only due to import statements

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~ Multiprocessing Synchronization TEST with Lock4Xi

»test_lock1_mp_xi2.py with Process4Xi, Queue4Xi and Pipe4Xi
ξ this demonstrates both pipe and queue communication and using locks with processes

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~ Multiprocessing and Pipes TEST with Process4Xi, Queue4Xi and Pipe4Xi

»test_pipe1_mp_xi2.py with Process4Xi, Queue4Xi and Pipe4Xi
ξ this demonstrates both pipe and queue communication
ξ creates multiprocessing pipes with consumer and publisher ends
ξ functions send messages to the pipe given
ξ main receives messages from the pipes updated by process funtions

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~ Multiprocessing and Queues TEST with Process4Xi and Queue4Xi

»test_demo1_mp_xi2.py with Process4Xi and Queue4Xi
ξ Multiprocessing test using dragonized multiprocessing modules /multiprocessing2xi
ξ phase I uses the original multiprocessing package
ξ phase II uses dragonized modules
ξ the only change in phase II for the application is to add 4Xi after class names !
ξ both phases produce the same outputs proving that dragonized modules work!

Changes if dragonized modules would be used (this is NOT the path to go !
»process.py
ξ from .forking import Popen <--- from forking import Popen i.e. imports from local folder the documented module

»forking.py <--- new one
ξ close(rhandle) # where is close defined ?
ξ #from ._multiprocessing import win32, Connection, PipeConnection <--- this must be changed

»forking.py <--- original one
ξ note that the compilation of the original module fails due to import

REASON IT!
ξ change imports in /multiprocessing2xi/old modules to local modules with old names
ξ for example: from multiprocessing.process import Process <--- from process import Process (imports from process.py)
ξ this would the hard way and NOT compatible with the orifinal multiporcessing

ACE IT!
ξ ace the dragonized layer on top of the multiprocessing package layer!

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~ Ctypes TEST with ArrayFunction4Xi

»test_ctypes_mp_xi2.py

changes due to testing in test_ctypes_mp_xi2.py
ξ one must use the module »arrayfunction4xi.py
ξ NOT the module »array4xi.py

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~ Connection dragonized

»connection.py
ξ global xmlrpclib

DragonXi2 Classes
01) Listener4Xi »listener4xi.py
02) SocketListener4Xi »socketlistener4xi.py
03) PipeListener4Xi »pipelistener4xi.py
04) ConnectionWrapper4Xi »connectionwrapper4xi.py
05) XmlListener4Xi »xmllistener4xi.py

DragonXi4 Classes
01) Listener4Xi »listener4xi.py
02) SocketListener4Xi »socketlistener4xi.py
03) PipeListener4Xi »pipelistener4xi.py
04) ConnectionWrapper4Xi »connectionwrapper4xi.py

05) XmlListener4Xi »xmllistener4xi.py
ξ global xmlrpclib4xi Δ Δ Δ
ξ def XmlClient4Xi
ξ import xmlrpc.client as xmlrpclib4xi

DragonXi2 Functions
01) arbitrary_address2xi »arbitrary_address4xi.py
02) address_type2xi »address_type4xi.py
03) Client4Xi »client4xi.py <--- note the capital!
04) Pipe2xi »pipe4xi.py <--- note the capital!
05) SocketClient2xi »socketclient4xi.py <--- note the capital!
06) PipeClient2xi »pipeclient4xi.py
07) ddeliver_challenge2xi »deliver_challenge4xi.py
08) answer_challenge2xi »answer_challenge4xi.py
09) _xml_dumps2xi »_xml_dumps4xi.py
10) _xml_loads2xi »_xml_loads4xi.py
11) XmlClient2xi »xmlclient4xi.py <--- note capital

DragonXi4 Functions
01) arbitrary_address4xi »arbitrary_address4xi.py
02) address_type4xi »address_type4xi.py
03) Client4Xi »client4xi.py <--- note the capital!
04) Pipe4xi »pipe4xi.py <--- note the capital!
05) SocketClient4xi »socketclient4xi.py
06) PipeClient4xi »pipeclient4xi.py
07) ddeliver_challenge4xi »deliver_challenge4xi.py
08) answer_challenge4xi »answer_challenge4xi.py
09) _xml_dumps4xi »_xml_dumps4xi.py
10) _xml_loads4xi »_xml_loads4xi.py

11) XmlClient4xi »xmlclient4xi.py <--- note capital
ξ import xmllistener4xi
ξ def XmlClient4Xi:
ξ import xmlrpc.client as xmlrpclib4xi #<-- defined by xmllistener4xi.py module

12) constant_connection4xi »constant_connection4xi.py *
13) constant_family4xi »constant_family4xi.py *
14) constant_system4xi »constant_system4xi.py *

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~ boundedsemaphore/condition/event/lock/rlock/semaphore/semlock4xi.py from syncronize.py

Original Module documented

»synchronize.py

To be dragonized
ξ from multiprocessing.process import current_process
ξ name = current_process().name

DragonXi2 Classes
01) BoundedSemaphore4Xi »boundedsemaphore4xi.py
02) Condition4Xi »condition4xi.py
03) Event4Xi »event4xi.py
04) Lock4Xi »lock4xi.py
05) RLock4Xi »rlock4xi.py
06) Semaphore4Xi »semaphore4xi.py
07) SemLock4Xi »semlock4xi.py

DragonXi4 Classes
01) BoundedSemaphore4Xi »boundedsemaphore4xi.py
02) Condition4Xi »condition4xi.py
03) Event4Xi »event4xi.py

04) Lock4Xi »lock4xi.py

Dragonized
ξ import current_process4xi
ξ from current_process4xi import get_current_process4xi
ξ from current_process4xi import set_current_process4xi
ξ cp2xi = get_current_process4xi()
ξ name2xi = cp2xi.name

05) RLock4Xi »rlock4xi.py

Dragonized
ξ import current_process4xi
ξ from current_process4xi import get_current_process4xi
ξ from current_process4xi import set_current_process4xi
ξ name4xi = current_process4xi().name

06) Semaphore4Xi »semaphore4xi.py
ξ import current_process4xi
ξ from current_process4xi import get_current_process4xi
ξ from current_process4xi import set_current_process4xi

07) SemLock4Xi »semlock4xi.py
ξ import current_process4xi
ξ from current_process4xi import get_current_process4xi
ξ from current_process4xi import set_current_process4xi

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~ Process module dragonized to new modules

Original Module Documented
»process.py

To be dragonized
ξ def _bootstrap(self): global _current_process <--- handling this properly in all dragonized modules is essential to the whole multiprocessingg system
ξ __all__ = ['Process', 'current_process', 'active_children']
ξ _listener = Listener(authkey=current_process().authkey)
ξ def current_process():
ξ return _current_process # _bootstrap function sets this global variable
ξ from multiprocessing import Process, current_process, active_children, Pool, util, connection
ξ return list(_current_process._children)
ξ for p in list(_current_process._children):
ξ _current_process._children.discard(p)
ξ count = next(_current_process._counter)
ξ self._identity = _current_process._identity + (count,)
ξ self._authkey = _current_process._authkey
ξ self._daemonic = _current_process._daemonic
ξ self._tempdir = _current_process._tempdir
ξ assert not _current_process._daemonic, \
ξ _current_process._children.add(self)
ξ _current_process._children.discard(self)
ξ if self is _current_process:
ξ global _current_process # defined here the global variable depicting current process
ξ _current_process = self # set here the global _current_process
ξ _current_process = _MainProcess() set in this module
ξ from multiprocessing import current_process, AuthenticationError
ξ _listener = Listener(authkey=current_process().authkey)
ξ conn = Client(address, authkey=current_process().authkey)
ξ if process.current_process()._identity==() and is_forking(sys.argv):
ξ process.current_process()._inheriting = True
ξ process.current_process()._inheriting = False
ξ authkey=process.current_process().authkey,
ξ process.current_process().name = data['name']
ξ process.current_process()._authkey = data['authkey']
ξ 'Process', 'current_process', 'active_children', 'freeze_support',
ξ from multiprocessing import Process, current_process, active_children, Pool, util, connection
ξ current_process()._manager_server = self
ξ authkey = current_process().authkey
ξ name = current_process().name
ξ server = getattr(current_process(), '_manager_server', None)
ξ not getattr(current_process(), '_inheriting', False)
ξ count = next(_current_process._counter)
ξ _listener = Listener(authkey=current_process().authkey)
ξ conn = Client(address, authkey=current_process().authkey)
ξ record.processName = current_process()._name
ξ if current_process()._tempdir is None:
ξ current_process()._tempdir = tempdir
ξ return current_process()._tempdir
ξ 'Process', 'current_process', 'active_children', 'freeze_support',
ξ self._parent = current_process()
ξ assert self._parent is current_process()
ξ current_process = threading.current_thread
ξ current_process()._children = weakref.WeakKeyDictionary()
ξ children = current_process()._children

DragonXi2 Classes
01) AuthenticationString4Xi »authenticationstring4xi.py
02) Process4Xi »process4xi.py
03) _mainprocess2xi »_mainprocess4xi.py

DragonXi4 Classes
01) AuthenticationString4Xi »authenticationstring4xi.py

02) Process4Xi »process4xi.py

Dragonized

Process4Xi _bootstrap method: <-- to be dragonized set current directory to process
ξ set_current_process4xi(self) #<--- sets the global object _current_process4xi using this function
ξ init_afterfork_registry4xi(self) #<--- added to initialize global objects in after_fork4xi.py
ξ init_afterfork_counter4xi(self) #<--- added to initialize global objects in after_fork4xi.py
ξ init_finalizer_registry4xi(self) #<--- initializes the global object
ξ clear_finalizer_registry4xi #<--- clears global object using the function

ξ import current_process4xi
ξ from current_process4xi import get_current_process4xi
ξ from current_process4xi import set_current_process4xi
ξ count2xi = next(_current_process4xi._counter)
ξ self._identity = _current_process4xi._identity + (count2xi,)
ξ self._authkey = _current_process4xi._authkey
ξ self._daemonic = _current_process4xi._daemonic
ξ self._tempdir = _current_process4xi._tempdir
ξ assert not _current_process4xi._daemonic, \
ξ _current_process4xi._children.add(self)
ξ _current_process4xi._children.discard(self)
ξ if self is _current_process4xi:
ξ if self is _current_process4xi:
ξ if self is _current_process4xi:
ξ set_current_process4xi(self) #<--- sets the global object using the function

03) _mainprocess4xi »_mainprocess4xi.py
ξ import current_process4xi
ξ from current_process4xi import get_current_process4xi
ξ from current_process4xi import set_current_process4xi

DragonXi2 Functions
04) current_process2xi »current_process4xi.py
ξ all methods with @property had to changed by copying the original code
ξ this is due to the fact that a method defined with @property can not be called
05) active_children2xi »active_children4xi.py
06) _cleanup2xi »_cleanup4xi.py

DragonXi4 Functions
04) current_process4xi »current_process4xi.py <--- continue here & *(make atomic*)
test_current_process4xi.py

To be done
ξ put global variable to OWL/XML files
ξ check modules below to see how they could be used for testing
ξ see standard and dragonxi2 multiprocessing tests
ξ find with find4xi.py "to be done" in all modules
ξ modify get method in all constant modules to call init if a global value is None

Dragonized
#A
active_children4xi.py
arbitrary_address4xi.py
arena4xi.py
assert_spawning4xi.py
authenticationstring4xi.py
autoproxy4xi.py
after_fork4xi.py
test_after_fork4xi.py Δ Δ Δ

#B
basemanager4xi.py <--- BaseManager4Xi base class for SyncManager4Xi
baseproxy4xi.py
boundedsemaphore4xi.py

#C
condition4xi.py
constant_managers4xi.py
convert_to_error4xi.py
current_process4xi.py
constant_util4xi.py
constant_heap4xi.py
constant_logger4xi.py
constant_synchronize4xi.py
constant_system4xi.py

#E
event4xi.py

#F
finalizer4xi.py <--- used by SyncManager4Xi __init__ method
finalize4xi.py
fromfd4xi.py

#G
get_command_line4xi.py <--- to be done: use this to test process from command line
get_preparation_data4xi.py

#I
import4xi.py

#L
lock4xi.py

#M
manager4xi.py <--- Manager4Xi function

#O
original_dir4xi.py

#P
pipe4xi.py
popen4xi.py
prepare4xi.py
process4xi.py

#Q
queue4xi.py

#R
rebuildproxy4xi.py
rebuild_connection4xi.py
rebuild_handle4xi.py
rebuild_socket4xi.py
reduce_connection4xi.py
reduce_handle4xi.py
rlock4xi.py

#S
semaphore4xi.py
semlock4xi.py
server4xi.py
syncmanager4xi.py <--- SyncManager4Xi class called by Manager4Xi function

#T
test_constant_forking4xi.py Δ Δ Δ

#_
_bootstrap4xi.py <--- to be done: test boot !
_check_logger_class4xi.py
_cleanup4xi.py
_get_listener4xi.py
_mainprocess4xi.py <--- to be done: test
_exit_function4xi.py

Standard Multiprocessing
__init__.py <--- Manager, Pipe, may functions with import and return
managers.py <--- SyncManager, BaseProxy etc essential classes

05) active_children4xi »active_children4xi.py

06) _cleanup4xi »_cleanup4xi.py

Dragonized
ξ import current_process4xi
ξ for p2xi in list(_current_process4xi._children):
ξ _current_process4xi._children.discard(p2xi)

07) terminate4xi »terminate4xi.py

08) original_dir4xi »original_dir4xi

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~ Managers module dragonized to new modules

Original Module managers.py documented
»managers.py
ξ from multiprocessing import Process, current_process, active_children, Pool, util, connection
ξ current_process()._manager_server = self
ξ authkey = current_process().authkey
ξ self._authkey = current_process().authkey
ξ name = current_process().name
ξ server = getattr(current_process(), '_manager_server', None)
ξ not getattr(current_process(), '_inheriting', False)
ξ authkey = current_process().authkey
ξ #imports from multiprocessing (current_process, active_children seem to be in /dummy)

DragonXi2 Classes
01) Token4Xi »token4xi.py
02) RemoteError4Xi »remoteerror4xi.py
03) Server4Xi »server4xi.py
04) State4Xi »state4xi.py
05) BaseManager4Xi »basemanager4xi.py
06) ProcessLocalSet4Xi »processlocalset4xi.py
07) BaseProxy4Xi »baseproxy4xi.py
11) Namespace4Xi »namespace4xi.py
12) Value4Xi »value4xi.py
14) IteratorProxy4Xi »iteratorproxy4xi.py
15) AcquirerProxy4Xi »acquirerproxy4xi.py
16) ConditionProxy4Xi »conditionproxy4xi.py
17) NamespaceProxy2xi »namespaceproxy4xi.py
18) ValueProxy4Xi »valueproxy4xi.py
20) ListProxy4Xi »listproxy4xi.py
24) SyncManager4Xi »syncmanager4xi.py
25) EventProxy4Xi »eventproxy4xi.py

DragonXi4 Classes
01) Token4Xi »token4xi.py
02) RemoteError4Xi »remoteerror4xi.py

03) Server4Xi »server4xi.py
ξ current_process4xi()._manager_server = self

04) State4Xi »state4xi.py

Dragonized
ξ global __slotsi__4xi
05) BaseManager4Xi »basemanager4xi.py
06) ProcessLocalSet4Xi »processlocalset4xi.py
07) BaseProxy4Xi »baseproxy4xi.py
11) Namespace4Xi »namespace4xi.py
12) Value4Xi »value4xi.py
14) IteratorProxy4Xi »iteratorproxy4xi.py
15) AcquirerProxy4Xi »acquirerproxy4xi.py
16) ConditionProxy4Xi »conditionproxy4xi.py
17) NamespaceProxy4Xi »namespaceproxy4xi.py
18) ValueProxy4Xi »valueproxy4xi.py
20) ListProxy4Xi »listproxy4xi.py

24) SyncManager4Xi »syncmanager4xi.py

Dragonized
ξ init_finalizer_registry4xi() #<--- dragonized initializing global _finalizer_registry4xi
ξ init_finalizer_counter4xi() #<--- dragonized initializing global _finalizer_counter4xi

ξ import current_process4xi
ξ authkey2xi = current_process4xi().authkey_param

25) EventProxy4Xi »eventproxy4xi.py

DragonXi2 Functions
08) »rebuildproxy4xi.py; RebuildProxy4Xi
09) »makeproxytype4xi.py; MakeProxyType4Xi
10) »autoproxy4xi.py; AutoProxy4Xi
13) »array4xi.py; Array4Xi

DragonXi4 Functions
08) »rebuildproxy4xi.py; RebuildProxy4Xi

Dragonized
ξ from current_process4xi import current_process4xi
ξ server2xi = getattr(current_process4xi(), '_manager_server', None)
ξ not getattr(current_process4xi(), '_inheriting', False)

09) »makeproxytype4xi.py; MakeProxyType4Xi
10) »autoproxy4xi.py; AutoProxy4Xi
13) »array4xi.py; Array4Xi

DragonXi2 Types
19) »baselistproxy4xi.py; BaseListProxy and BaseListProxy4Xi
21) »dictproxy4xi.py; DictProxy and DictProxy4Xi
22) »arrayproxy4xi.py; ArrayProxy and ArrayProxy4Xi
23) »poolproxy4xi.py; PoolProxy and PoolProxy4Xi
34) »listener_client4xi.py; listener_client2xi

DragonXi4 Types
19) »baselistproxy4xi.py; BaseListProxy and BaseListProxy4Xi
21) »dictproxy4xi.py; DictProxy and DictProxy4Xi
22) »arrayproxy4xi.py; ArrayProxy and ArrayProxy4Xi
23) »poolproxy4xi.py; PoolProxy and PoolProxy4Xi
34) »listener_client4xi.py; listener_client4xi

DragonXi2 functions
27) »reduce_array4xi.py; reduce_array2xi
28) »rebuild_as_list4xi.py; rebuild_as_list2xi
29) »pickle4xi.py; pickle2xi (no function available but just code)
30) »dispatch4xi.py; dispatch2xi
31) »convert_to_error4xi.py; convert_to_error2xi
32) »all_methods4xi.py; all_methods2xi
33) »public_methods4xi.py; public_methods2xi
34) »debug_info4xi.py; debug_info2xi

DragonXi4 functions
27) »reduce_array4xi.py; reduce_array4xi
28) »rebuild_as_list4xi.py; rebuild_as_list4xi
29) »pickle4xi.py; pickle4xi (no function available but just code)
30) »dispatch4xi.py; dispatch4xi
31) »convert_to_error4xi.py; convert_to_error4xi
32) »all_methods4xi.py; all_methods4xi
33) »public_methods4xi.py; public_methods4xi
34) »debug_info4xi.py; debug_info4xi

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~ Forking module dragonized

Original Module commented
»forking.py
ξ if process.current_process()._identity==() and is_forking(sys.argv):
ξ process.current_process()._inheriting = True
ξ process.current_process()._inheriting = False
ξ authkey=process.current_process().authkey,
ξ process.current_process().name = data['name']
ξ process.current_process()._authkey = data['authkey']
ξ 'Process', 'current_process', 'active_children', 'freeze_support'

DragonXi2 Classes
01) ForkingPickler4Xi »forkingpickler4xi.py
02) _C2xi »_c4xi.py
03) Popen2xi »popen4xi.py

DragonXi4 Classes
01) ForkingPickler4Xi »forkingpickler4xi.py
02) _C4Xi »_c4xi.py
03) Popen4Xi »popen4xi.py

ξ global _python_exe

ξ if process.current_process()._identity==() and is_forking(sys.argv):
ξ process.current_process()._inheriting = True
ξ process.current_process()._inheriting = False
ξ authkey=process.current_process().authkey,

DragonXi2 Functions
04) assert_spawning2xi »assert_spawning4xi.py
05) _reduce_method2xi »_reduce_method4xi.py
06) _reduce_method_descriptor2xi »_reduce_method_descriptor4xi.py
07) _reduce_partial2xi »_reduce_partial4xi.py
08) dump2xi »dump4xi.py
09) duplicate2xi »duplicate4xi.py
10) is_forking2xi »is_forking4xi.py
11) get_command_line2xi »get_command_line4xi.py
11) get_preparation_data2xi »get_preparation_data4xi.py
12) prepare2xi »prepare4xi.py
13) _rebuild_partial2xi »_rebuild_partial4xi.py *

DragonXi4 Functions
04) assert_spawning4xi »assert_spawning4xi.py
05) _reduce_method4xi »_reduce_method4xi.py
06) _reduce_method_descriptor4xi »_reduce_method_descriptor4xi.py
07) _reduce_partial4xi »_reduce_partial4xi.py
08) dump4xi »dump4xi.py
09) duplicate4xi »duplicate4xi.py
10) is_forking4xi »is_forking4xi.py
11) get_command_line4xi »get_command_line4xi.py
ξ from current_process4xi import current_process4xi
ξ if current_process4xi()._identity==() and is_forking(sys.argv):
12) get_preparation_data4xi »get_preparation_data4xi.py
ξ import current_process4xi
ξ from current_process4xi import current_process4xi
ξ authkey=current_process4xi().authkey,

13) prepare4xi »prepare4xi.py
ξ import current_process4xi
ξ from current_process4xi import current_process4xi
ξ current_process4xi().name = data['name']
ξ current_process4xi()._authkey = data['authkey']

14) _rebuild_partial4xi »_rebuild_partial4xi.py *
15) close4xi »close4xi.py *
16) constant_process4xi »constant_process4xi.py *
17) constant_logger4xi »constant_logger4xi.py *
18) constant_forking4xi »constant_forking4xi.py *

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~ Heap module dragonized

Original Module commented
»heap.py
ξ 'Process', 'current_process', 'active_children', 'freeze_support',

DragonXi2 Classes
01) Arena2xi »arena4xi.py
02) Heap2xi »heap4xi.py
03) BufferWrapper2xi »bufferwrapper4xi.py

DragonXi4 Classes
01) Arena4Xi »arena4xi.py
02) Heap4Xi »heap4xi.py
03) BufferWrapper4Xi »bufferwrapper4xi.py

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~ Pool module dragonized

Original Module commented
»pool.py

ξ from multiprocessing import Process, current_process, active_children, Pool, util, connection
ξ server = getattr(current_process(), '_manager_server', None)
ξ not getattr(current_process(), '_inheriting', False)
ξ count = next(_current_process._counter)

DragonXi2 Modules defining Classes
01) Pool4Xi »pool4xi.py
02) ApplyResult4Xi »applyresult4xi.py
03) MapResult4Xi »mapresult4xi.py
04) IMapIterator4Xi »imapiterator4xi.py
05) IMapUnorderedIterator4Xi »imapunorderediterator4xi.py
06) ThreadPool4Xi »threadpool4xi.py

DragonXi4 Modules defining Classes
01) Pool4Xi »pool4xi.py
02) ApplyResult4Xi »applyresult4xi.py
03) MapResult4Xi »mapresult4xi.py
04) IMapIterator4Xi »imapiterator4xi.py
05) IMapUnorderedIterator4Xi »imapunorderediterator4xi.py
06) ThreadPool4Xi »threadpool4xi.py

DragonXi4 Modules defining Function
01) constant_pool4xi.py »constant_pool4xi.py

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~ Queues module dragonized

Original Module commented
»queues.py

DragonXi2 Classes
01) Queue4Xi »queue4xi.py
02) JoinableQueue4Xi »joinablequeue4xi.py
03) SimpleQueue4Xi »simplequeue4xi.py

DragonXi4 Classes

01) Queue4Xi »queue4xi.py
ξ import current_process4xi

02) JoinableQueue4Xi »joinablequeue4xi.py
03) SimpleQueue4Xi »simplequeue4xi.py

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~ Reduction module dragonized

Original Module documented
»reduction.py

ξ global _lock, _listener, _cache
ξ global _listener

ξ from multiprocessing import current_process
ξ _listener = Listener(authkey=current_process().authkey)
ξ conn = Client(address, authkey=current_process().authkey)
ξ current_process()._manager_server = self
ξ server = getattr(current_process(), '_manager_server', None)
ξ server = getattr(current_process(), '_manager_server', None)
ξ current_process()._manager_server = self
ξ server = getattr(current_process(), '_manager_server', None)
ξ server = getattr(current_process(), '_manager_server', None)

DragonXi2 modules defining Funtions
01) send_handle2xi »send_handle4xi.py
02) recv_handle2xi »recv_handle4xi.py
03) _reset2xi »_reset4xi.py
04) _get_listener2xi »_get_listener4xi.py
05) _serve2xi »_serve4xi.py
06) reduce_handle2xi »reduce_handle4xi.py
07) rebuild_handle2xi »rebuild_handle4xi.py
08) reduce_connection2xi »reduce_connection4xi.py
09) rebuild_connection2xi »rebuild_connection4xi.py
10) fromfd2xi »fromfd4xi.py
11) rebuild_socket2xi »rebuild_socket4xi.py

DragonXi4 modules defining Funtions
01) send_handle4xi »send_handle4xi.py
02) recv_handle4xi »recv_handle4xi.py
03) _reset4xi »_reset4xi.py *

04) _get_listener4xi »_get_listener4xi.py
ξ import current_process4xi
ξ _listener4xi = Listener4Xi(authkey=current_process4xi().authkey)

05) _serve4xi »_serve4xi.py
06) reduce_handle4xi »reduce_handle4xi.py

07) rebuild_handle4xi »rebuild_handle4xi.py
ξ from current_process4xi import current_process4xi
ξ conn2xi = Client4Xi(address2xi, authkey2xi=current_process4xi().authkey)

08) reduce_connection4xi »reduce_connection4xi.py
ξ from current_process4xi import current_process4xi

09) rebuild_connection4xi »rebuild_connection4xi.py
ξ from current_process4xi import current_process4xi

10) fromfd4xi »fromfd4xi.py
ξ from current_process4xi import current_process4xi

11) rebuild_socket4xi.py »rebuild_socket4xi.py
ξ from current_process4xi import current_process4xi

12) _ebuild_socket4xi.py »rebuild_socket4xi.py

13) _cache4xi »_cache4xi4xi.py *
ξ global _cache4xi

14) _lock4xi »_lock4xi4xi.py *
ξ global _lock4xi

15) _listener4xi »_listener4xi4xi.py *
ξ global _listener4xi

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~ Sharedctypes

Original Module documented
»sharedctypes.py

DragonXi2 Modules defining Classes
01) SynchronizedBase4Xi »synchronizedbase4xi.py
02) Synchronized4Xi »synchronizedstring4xi.py
03) SynchronizedArray4Xi »synchronizedarray4xi.py
04) SynchronizedString4Xi »synchronizedstring4xi.py

DragonXi4 Modules defining Classes
01) SynchronizedBase4Xi »synchronizedbase4xi.py
02) Synchronized4Xi »synchronizedstring4xi.py
03) SynchronizedArray4Xi »synchronizedarray4xi.py
04) SynchronizedString4Xi »synchronizedstring4xi.py

DragonXi2 Modules defining Funtions
05) _new_value2xi »_new_value4xi.py
06) RawValue4Xi »rawvalue4xi.py
07) RawArray4Xi »rawarray4xi.py
08) ValueFunction4Xi »valuefunction4xi.py
09) ArrayFunction2xi »arrayfunction4xi.py
10) copy2xi »copy4xi.py
11) synchronized_function2xi »synchronized_function4xi.py
12) reduce_ctype2xi »reduce_ctype4xi.py
13) rebuild_ctype2xi »rebuild_ctype4xi.py
14) make_property2xi »make_property4xi.py

DragonXi4 Modules defining Funtions
05) _new_value4xi »_new_value4xi.py
06) RawValue4Xi »rawvalue4xi.py
07) RawArray4Xi »rawarray4xi.py
08) ValueFunction4xi »valuefunction4xi.py
09) ArrayFunction4xi »arrayfunction4xi.py
10) copy4xi »copy4xi.py
11) synchronized_function4xi »synchronized_function4xi.py
12) reduce_ctype4xi »reduce_ctype4xi.py
13) rebuild_ctype4xi »rebuild_ctype4xi.py
14) make_property4xi »make_property4xi.py

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~ Util module dragonized

Original Module documented
»util.py

ξ global _log_to_stderr
ξ global _logger
ξ _logger = logging.getLogger(LOGGER_NAME) # sets the global _logger
ξ global _log_to_stderr
ξ global _exiting

ξ from multiprocessing.process import current_process, active_childre
ξ record.processName = current_process()._name
ξ if current_process()._tempdir is None:
ξ current_process()._tempdir = tempdir
ξ return current_process()._tempdir

DragonXi2 Modules defining Classes
01) Finalize4Xi »finalize4xi.py
02) ForkAwareThreadLock4Xi »forkawarethreadlock4xi.py
03) ForkAwareLocal4Xi »forkawarelocal4xi.py

DragonXi4 Modules defining Classes
01) Finalize4Xi »finalize4xi.py
02) ForkAwareThreadLock4Xi »forkawarethreadlock4xi.py
03) ForkAwareLocal4Xi »forkawarelocal4xi.py

DragonXi2 Modules defining Funtions
04) sub_debug2xi »sub_debug4xi.py
05) debug2xi »debug4xi.py
06) info2xi »info4xi.py
07) sub_warning2xi »sub_warning4xi.py
08) _check_logger_class2xi »_check_logger_class4xi.py
09) get_logger2xi »get_logger4xi.py
10) log_to_stderr2xi »log_to_stderr4xi.py
11) get_temp_dir2xi »get_temp_dir4xi.py
12) _run_after_forkers2xi »_run_after_forkers4xi.py
13) register_after_fork2xi »register_after_fork4xi.py

DragonXi4 Modules defining Funtions
04) sub_debug4xi »sub_debug4xi.py
05) debug4xi »debug4xi.py
06) info4xi »info4xi.py
07) sub_warning4xi »sub_warning4xi.py
08) _check_logger_class4xi »_check_logger_class4xi.py
ξ import current_process4xi
ξ record.processName = current_process4xi()._name

09) get_logger4xi »get_logger4xi.py
ξ global _log_to_stderr

10) log_to_stderr4xi »log_to_stderr4xi.py
ξ global _log_to_stderr4xi

11) get_temp_dir4xi »get_temp_dir4xi.py
ξ from current_process4xi import current_process4xi
ξ if current_process4xi()._tempdir is None:
ξ current_process4xi()._tempdir = tempdir
ξ return current_process4xi()._tempdir
12) _run_after_forkers4xi »_run_after_forkers4xi.py

13) register_after_fork4xi »register_after_fork4xi.py
ξ init_afterfork_registry4xi(self) #<--- added to initialize global objects in after_fork4xi.py
ξ init_afterfork_counter4xi(self) #<--- added to initialize global objects in after_fork4xi.py

14) _bootstrap4xi »_bootstrap4xi *
ξ from current_process4xi import current_process4xi
ξ current_process4xi._current_process4xi = self

15) _run_after_forkers4xi »_run_after_forkers4xi *
16) _run_finalizers4xi »_run_finalizers4xi *

17) ffinalizer4xi »finalizer4xi *
ξ global _finalizer_registry4xi

18) is_exiting4xi »is_exiting4xi *
ξ global _exiting4xi #<--- set by process4xi.py function _bootstrap(self)

19) after_fork4xi »after_fork4xi *
20) constant_util4xi »constant_util4xi *

21) set_logger4xi »set_logger4xi *
ξ sets global objects _logger4xi and _log_to_stderr4xi

22) _exit_function4xi »_exit_function4xi *
ξ global _exiting4xi

23) _inalizer4xi »_finalizer4xi *
ξ provides init_finalizers4xi function

24) set_log_to_stderr4xi »set_log_to_stderr4xi *

DragonXi2 Module to contain debugging functions and classes
30) logger2xi »logger4xi.py

DragonXi4 Module to contain debugging functions and classes
30) logger4xi »logger4xi.py
ξ global _logger4xi
ξ global _log_to_stderr4xi
ξ functions processing above global variables

~[Σ] ~[Ω] ~[Δ]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~ BLOG

Studio4Xi

Links:
ξ »Multiprocessing4Xi
ξ »Scope4xi

March-April, 2015

»URI2TEST4YO
»URL2TEST4YO
»WEB2TEST4YO
»SYSTEMTESTING2URI4YO
»Programs for URI
»Test Data

Backup
ξ both software and testdata locally as well as FTP upload to server/ download to other systems
ξ J:\temp\yosense\test2generate4server\dragon <-- to create test2dragon
ξ J:\temp\yosense\test2generate4server\33 <-- to create test2hirtythree
ξ ...
ξ J:\temp\yosense\test2generate4server\00 <-- to create test2zero
ξ F:\temp\yosense\test2dragon <-- to run shoot2dragon4uri5test.py
ξ U:\temp\yosense <-- test data backup in USB disk
ξ H:\Backup\temp\yosense <-- test data backup in hard disk
ξ \home\icefellow\webapps\yodragonxiorg\web\test <-- test data in server for testing in different systems
ξ »URI2TEST4YO <-- tests
ξ »URI2TEST4YO <-- tests

WEB2TEST4YO(password protected)

»test2dragon
ξ complete portal in testing!

====================================================================================================================
URI2TEST4YO
====================================================================================================================
QTY
Xi [ACK] 54262
ξ »"file:///F:/temp/yosense/test2dragon/uri2dragon4yo.html" target="_blank">uri2dragon4yo - (dragon 1-12)
00 [ACK] 64 »"file:///D:/temp/yosense/test2zero/uri2zero4yo.html" target="_blank">uri2zero4yo - (hydro)
01 [ACK] 21 »"file:///G:/temp/yosense/test2one/uri2one4yo.html" target="_blank">uri2one4yo - (diesel)
02 [ACK] 70 »"file:///H:/temp/yosense/test2two/uri2two4yo.html" target="_blank">uri2two4yo - (co2)
03 [ACK] 130 »"file:///I:/temp/yosense/test2three/uri2three4yo.html" target="_blank">uri2three4yo - (bio)
04 [ACK] 279 »"file:///K:/temp/yosense/test2four/uri2four4yo.html" target="_blank">uri2four4yo - (aero)
05 [ACK] 41 »"file:///L:/temp/yosense/test2five/uri2five4yo.html" target="_blank">uri2five4yo - (arts)
06 [ACK] 120 »"file:///M:/temp/yosense/test2six/uri2six4yo.html" target="_blank">uri2six4yo - (creativity)
07 [ACK] 0143 »"file:///N:/temp/yosense/test2seven/uri2seven4yo.html" target="_blank">uri2seven4yo - (web)
08 [ACK] 0258 »"file:///O:/temp/yosense/test2eight/uri2eight4yo.html" target="_blank">uri2eight4yo - (design)
09 [ACK] 0378 »"file:///P:/temp/yosense/test2nine/uri2nine4yo.html" target="_blank">uri2nine4yo - (hw)

10 [ACK] 0005 »"file:///Q:/temp/yosense/test2ten/uri2ten4yo.html" target="_blank">uri2ten4yo - (biotope)
11 [ACK] 0011 »"file:///F:/temp/yosense/test2eleven/uri2eleven4yo.html" target="_blank">uri2eleven4yo - (lex)
12 [ACK] 56 »"file:///G:/temp/yosense/test2twelve/uri2twelve4yo.html" target="_blank">uri2twelve4yo - (tv)
13 [ACK] 0060 »"file:///M:/temp/yosense/test2thirteen/uri2thirteen4yo.html" target="_blank">uri2thirteen4yo - (nano)
14 [ACK] 0134 »"file:///K:/temp/yosense/test2fourteen/uri2fourteen4yo.html" target="_blank">uri2fourteen4yo - (net)
15 [ACK] 0003 »"file:///L:/temp/yosense/test2fifteen/uri2fifteen4yo.html" target="_blank">uri2fifteen4yo - (org)
16 [ACK] 0016 »"file:///M:/temp/yosense/test2sixteen/uri2sixteen4yo.html" target="_blank">uri2sixteen4yo - (owl)
17 [ACK] 0093 »"file:///N:/temp/yosense/test2seventeen/uri2seventeen4yo.html" target="_blank">uri2seventeen4yo - (rd)
18 [ACK] 0164 »"file:///O:/temp/yosense/test2eighteen/uri2eighteen4yo.html" target="_blank">uri2eighteen4yo - (realm)
19 [ACK] 0094 »"file:///P:/temp/yosense/test2nineteen/uri2nineteen4yo.html" target="_blank">uri2nineteen4yo - (sensor)

20 [ACK] 0006 »"file:///Q:/temp/yosense/test2twenty/uri2twenty4yo.html" target="_blank">uri2twenty4yo - (sports)
21 [ACK] 0092 »"file:///F:/temp/yosense/test2twentyone/uri2twentyone4yo.html" target="_blank">uri2twentyone4yo - (sw)
22 [ACK] 0057 »"file:///G:/temp/yosense/test2twentytwo/uri2twentytwo4yo.html" target="_blank">uri2twentytwo4yo - (mobi)
23 [ACK] 19711 »"file:///I:/temp/yosense/test2twentythree/uri2twentythree4yo.html" target="_blank">uri2twentythre4yo - (uas and ugs)
24 [ACK] 0269 »"file:///K:/temp/yosense/test2twentyfour/uri2twentyfour4yo.html" target="_blank">uri2twentyfour4yo - (solar)
25 [ACK] 0139 »"file:///L:/temp/yosense/test2twentyfive/uri2twentyfive4yo.html" target="_blank">uri2twentyfive4yo - (coal)
26 [ACK] 0073 »"file:///M:/temp/yosense/test2twentysix/uri2twentysix4yo.html" target="_blank">uri2twentysix4yo - (gas)
27 [ACK] 0070 »"file:///N:/temp/yosense/test2twentyseven/uri2twentyseven4yo.html" target="_blank">uri2twentyseven4yo - (electric)
28 [ACK] 0192 »"file:///O:/temp/yosense/test2twentyeight/uri2twentyeight4yo.html" target="_blank">uri2twentyeight4yo - (fusion, np)
29 [ACK] 0152 »"file:///P:/temp/yosense/test2twentynine/uri2twentynine4yo.html" target="_blank">uri2twentynine4yo - (geo and h)

30 [ACK] 0074 »"file:///Q:/temp/yosense/test2thirty/uri2thirty4yo.html" target="_blank">uri2thirty4yo - (li)
31 [ACK] 0028 »"file:///F:/temp/yosense/test2thirtyone/uri2thirtyone4yo.html" target="_blank">uri2thirtyone4yo - (oil)
32 [ACK] 0216 »"file:///G:/temp/yosense/test2thirtytwo/uri2thirtytwo4yo.html" target="_blank">uri2thirtytwo4yo - (ocean,water,wind)
33 [ACK] 0005 »"file:///M:/temp/yosense/test2thirtythree/uri2thirtythree4yo.html" target="_blank">uri2thirtythree4yo - (yoDragonXiCom - new)
====================================================================================================================
Σ [ACK] 54574 [ACK] shoot2dragon4uri.py / (23176 with automate2ref4uri.py depending on configurations)
====================================================================================================================

====================================================================================================================
URL2TEST4YO
====================================================================================================================

FastBlack
»uri2dragon4yo
QTY
00 [NACK] 0000 »"file:///D:/temp/yosense/test2zero/uri2zero4yo.html" target="_blank">uri2zero4yo
01 [ ACK] 0417 »"file:///G:/temp/yosense/test2one/uri2one4yo.html" target="_blank">uri2one4yo
02 [ ACK] 0095 »"file:///H:/temp/yosense/test2two/uri2two4yo.html" target="_blank">uri2two4yo
03 [ ACK] 0006 »"file:///I:/temp/yosense/test2three/uri2three4yo.html" target="_blank">uri2three4yo
04 [ ACK] 0710 »"file:///K:/temp/yosense/test2four/uri2four4yo.html" target="_blank">uri2four4yo
05 [ ACK] 0154 »"file:///L:/temp/yosense/test2five/uri2five4yo.html" target="_blank">uri2five4yo
06 [ ACK] 0118 »"file:///M:/temp/yosense/test2six/uri2six4yo.html" target="_blank">uri2six4yo
07 [ ACK] 0233 »"file:///N:/temp/yosense/test2seven/uri2seven4yo.html" target="_blank">uri2seven4yo
08 [NACK] 0000 »"file:///O:/temp/yosense/test2eight/uri2eight4yo.html" target="_blank">uri2eight4yo
09 [NACK] 0000 »"file:///P:/temp/yosense/test2nine/uri2nine4yo.html" target="_blank">uri2nine4yo

10 [NACK] 0000 »"file:///Q:/temp/yosense/test2ten/uri2ten4yo.html" target="_blank">uri2ten4yo
11 [NACK] 0000 »"file:///F:/temp/yosense/test2eleven/uri2eleven4yo.html" target="_blank">uri2eleven4yo
12 [NACK] 0000 »"file:///G:/temp/yosense/test2twelve/uri2twelve4yo.html" target="_blank">uri2twelve4yo
13 [NACK] 0000 »"file:///M:/temp/yosense/test2thirteen/uri2thirteen4yo.html" target="_blank">uri2thirteen4yo
14 [NACK] 0000 »"file:///K:/temp/yosense/test2fourteen/uri2fourteen4yo.html" target="_blank">uri2fourteen4yo
15 [NACK] 0000 »"file:///L:/temp/yosense/test2fifteen/uri2fifteen4yo.html" target="_blank">uri2fifteen4yo
16 [NACK] 0000 »"file:///M:/temp/yosense/test2sixteen/uri2sixteen4yo.html" target="_blank">uri2sixteen4yo
17 [NACK] 0000 »"file:///N:/temp/yosense/test2seventeen/uri2seventeen4yo.html" target="_blank">uri2seventeen4yo
18 [NACK] 0000 »"file:///O:/temp/yosense/test2eighteen/uri2eighteen4yo.html" target="_blank">uri2eighteen4yo
19 [NACK] 0000 »"file:///P:/temp/yosense/test2nineteen/uri2nineteen4yo.html" target="_blank">uri2nineteen4yo
20 [NACK] 0000 »"file:///Q:/temp/yosense/test2twenty/uri2twenty4yo.html" target="_blank">uri2twenty4yo

21 [NACK] 0000 »"file:///F:/temp/yosense/test2twentyone/uri2twentyone4yo.html" target="_blank">uri2twentyone4yo
22 [NACK] 0000 »"file:///G:/temp/yosense/test2twentytwo/uri2twentytwo4yo.html" target="_blank">uri2twentytwo4yo
23 [NACK] 0000 »"file:///I:/temp/yosense/test2twentythree/uri2twentythree4yo.html" target="_blank">uri2twentythre4yo
24 [NACK] 0000 »"file:///K:/temp/yosense/test2twentyfour/uri2twentyfour4yo.html" target="_blank">uri2twentyfour4yo
25 [NACK] 0000 »"file:///L:/temp/yosense/test2twentyfive/uri2twentyfive4yo.html" target="_blank">uri2twentyfive4yo
26 [NACK] 0000 »"file:///M:/temp/yosense/test2twentysix/uri2twentysix4yo.html" target="_blank">uri2twentysix4yo
27 [NACK] 0000 »"file:///N:/temp/yosense/test2twentyseven/uri2twentyseven4yo.html" target="_blank">uri2twentyseven4yo
28 [NACK] 0000 »"file:///O:/temp/yosense/test2twentyeight/uri2twentyeight4yo.html" target="_blank">uri2twentyeight4yo
29 [NACK] 0000 »"file:///P:/temp/yosense/test2twentynine/uri2twentynine4yo.html" target="_blank">uri2twentynine4yo

30 [NACK] 0000 »"file:///Q:/temp/yosense/test2thirty/uri2thirty4yo.html" target="_blank">uri2thirty4yo
31 [NACK] 0000 »"file:///F:/temp/yosense/test2thirtyone/uri2thirtyone4yo.html" target="_blank">uri2thirtyone4yo
32 [NACK] 0000 "file:///G:/temp/yosense/test2thirtytwo/uri2thirtytwo4yo.html" target="_blank">uri2thirtytwo4yo
33 [NACK] 0000 »"file:///M:/temp/yosense/test2thirtythree/uri2thirtythree4yo.html" target="_blank">uri2thirtythree4yo
================================
Σ [ACK] 4784
================================

DRAGONTEST2URI4YO
ξ Step(1) take sense folder(!) to test2dragon sense folder (it has special menu referring only to subdomain)
ξ Step(2) URI test Step(4) URL test
ξ Step(4) copy domain folder(!) to a) test2master b) back to its original test location for ξ »automate2ref4uri

SYSTEMTESTING2URI4YO
ξ »test2dragon
ξ goal to have URL links concentrated to minimum number of folders where automatic verifications could be run now and then
ξ {spec,sense} verifications started - {scope4xi,studio4xi,sw4xi} after that
ξ upgraded bp and vc by also referring to content at www.dragonxi.com and at www.yourdragonxi.org
ξ {spec, vc, brand, nda, index.html} verified - biz remains mystery (consider to delete ti and verify URIs only)!

URL tests in test2dragon
Status Subfolder Details
==============================================================================================================================
Cluster 2 [URI]: 17489 [ACK] [URI]: 0 [NACK] - [URL]: [URL]: 93042 [ACK] [URL]: 5701 [NACK] *** <-- {'spec' + 'sense'}
Cluster 1 [ACK] [URI]: 2523 [ACK] [URL]: 2469 [ACK] <-- 'bp'(*)+'brand'+'ss'+'vc'(*)+'nda' +index!
[NACK] biz
[NACK] bp [URI]: 752 [ACK] [URL]: 1112 [ACK] / [URI]: 752 [ACK] [URL]: 1093 [ACK] <-- bp_ref and bp_019 updated!
[NACK] brand [URI]: 623 [ACK] [URL]: 37 [ACK]
[NACK] design [URI]: 207 [ACK] [URL]: 127 [ACK]
[NACK] icewaves
[NACK] scope4xi
[NACK] sense new energy (solar, hydrogen,wind) got busted, whereas traditional ones such as diesel, coal continue while electricity industry booms!
[NACK] spec
[NACK] ss [URI]: 93 [ACK] [URL]: 4 [ACK]
[NACK] studio4xi
[NACK] sw4xi
[NACK] temp
[NACK] vc
[NACK] web
==============================================================================================================================

URI tests with Browser
ξ index-sense-xi2.html to be moved to /sense/ level from root -also in the server side and in Linux workstations
ξ shoot2dragon4uri.py verified only subfolders based on settings!
ξ index-sense-xi2.html to be upgraded; usa, china, eu, org removed - (shoot2dragon4uri.py verifies only existing links)!
integrate energy and reverify it:
ξ F:\temp\yosense\test2dragon\sense\e
ξ file:///F:/temp/yosense/test2dragon/sense/e/index-e-xi2.html
ξ file:///F:/temp/yosense/test2dragon/sense/e/index-e-xi2.html#001
ξ file:///F:/temp/yosense/test2dragon/sense/e/oil/index-oil-xi2.html <-- Oil is missing!

URI tests in two workstations via web
ξ 54222 [ACK] (fb)!
ξ completed 31 March 2015
ξ FTP uploaded to server as test2dragon4fb /test2dragon4riika and downloaded to Linux system

HaLongBay
ξ automatic conversion to be considered (over 6000 files!) to change Plone CMS object hyperlinks to standard hyperlinks
ξ on the other hand 9090 local ZIM/Plone configuration works well!

Domain Data for System test
ξ test2thirtytwo Titan <-- (yoDragonXiOrg - new => \WebFaction\Web306\FTPWeb306\home\icefellow\webapps\yodragonxiorg
ξ test2thirtythree Logic <-- (yoDragonXiCom - existing)<=> \WebFaction\Web306\FTPWeb306\home\icefellow\webapps\yodragonxicom

URL Common
ξ web 143 [ACK] -integrated more from webfaction folder to URI-test sw4xi, scope4xi and studio4xi
ξ creativity [URL]: 154 [ACK] - 100% alive!
ξ biz 713 [ACK] 8 [NACK]
ξ biotope 6 [ACK] - 100% alive!
ξ arts 95 [ACK] - 100% alive!
ξ aero industry is not the one to be invested if one looks how many aero companies have got busted!
ξ [URL]: 433 [ACK] 138 [NACK] <=> 571 sites of which over 20% busted - final result 417 [ACK]
ξ due to Win 8.1 inability to handle many concurrent access to web had to run URL tests one after another!
ξ i.e. it was not possible to run automate2ref4uri.py because it activates 33 processes to access internet!
ξ therefore the following tedious work flow had to be implemented:
ξ 1) took test2one...test233 sense folder to test2dragon sense folder and run shoot2dragon4uri5test for each
ξ 2) copied uri2dragon4yo.html to test2xxxxxxxx folder, swapped it with uri2xxxxxxxx4yo.html, xxxxxxxx = zero ... thirtythree
ξ 3) copied uri2zero4yo.html ... uri2thirtythree4yo.html H:\Backup\temp\yosense to be able to FTP upload in easier wayr
ξ 4) analyzed uri2zero4yo.html ... uri2thirtythree4yo.html in several workstations running Win 7.1 and Linux Ubuntu
ξ however, with the help of web and by distributing tasks it would be possible run tests in 33 different locations!
ξ also, one powerful system could run all 33 tests and distribute each test and its results to 33 locations to fix URLs

ξ TOTAL STATISTICS: [URI]: 1626 [ACK] & [URL]: 663 [ACK] - test2twentythree completed for UAS and UAS!
ξ ξ »version4xi - search automate2ref4uri.py
ξ due to Windows 8.1's inability to handle simultaneous access to web had to use shoot2dragon4uri5test.py and to pick one test at a time for test2dragon
ξ lesson to those referring to non-english sites: always refer to their original home site!

UAS
ξ first test revealed the following: [URL]: 639 [ACK] <-- still alive! [URL]: 119 [NACK] <-- busted!
ξ U.S., UK, Germany and Chine rule UAS business as well as research and development!
ξ secure https has been taken into use by government sites
ξ many of small UAS developers and vendors busted, specially those not in California (Ohio, Rotamax ...)!

UGS
ξ some UGS companies have switched from military to business, even to environment business!
ξ UK companies have bought many UGS suppliers in North America, better than got busted as has happened to many of them!

URI Tests
ξ completed, see statistics URI2TEST4YO(local)

Challenges:
ξ hit by mystery ../en-cn-bio-xi2.html in en-bj-cn-bio-xi2.html at F://temp//yosense//test2dragon//sense//e//solar//cn//bj//en-bj-cn-bio-xi2.html <-- should be en-bj-cn-solar-xi2.html
ξ file:///F:/temp/yosense/test2dragon/sense/e/bio/cn/en-cn-bio-xi2.html <-- browser in main
ξ file:///F:/temp/yosense/test2dragon/sense/e/bio/cn/bj/en-bj-cn-bio-xi2.html <-- browser click back in unverified one!
ξ file:///F:/temp/yosense/test2dragon/sense/e/bio/cn/en-cn-bio-xi2.html <-- browser back main
ξ file:///F:/temp/yosense/test2dragon/sense/e/bio/cn/qh/en-qh-cn-bio-xi2.html <-- verified ok!
[ ACK] Verifying URIs in »en-cq-cn-solar-xi2.html
[NACK] Verifying URIs in »en-bj-cn-bio-xi2.html <-- solar has been dropped by shoot2dragon4uri.py!
[ ACK] Verifying URIs in »en-ah-cn-solar-xi2.html
ξ bj/en-bj-cn-bio-xi2.html <-- referred by en-cn-bio-xi2.html AND en-bj-cn-bio-xi2.html does exist!
ξ file:///K:/temp/yosense/test2twentyfour/uri2twentyfour4yo.html
ξ Verifying URIs in �K://temp//yosense//test2twentyfour//sense//e//bio//cn//bj//en-bj-cn-bio-xi2.html <-- [ACK] <=> test2twentyfour is passed by generated code!

Conclusions:
ξ 1) yes, problem can be repeated and it comes whether you run shoot2dragon4uri5test or automatate2ref4uri !
ξ 2) strange, shoot2twentyfour4uri.py handles it right!
ξ 3) if only e/bio in test2dragon it passes ok!
ξ 4) if 31 solar energy added, then NACK!
ξ 5) yes; en-ah-cn-solar-xi2.html is ok named whereas en-bj-cn-bio-xi2.html is WRONG!
ξ 6) en-cn-solar-xi2.html DOES call en-bj-cn-solar-xi2.html and succees!
ξ 7) renamed it to en-bj-cn-solar-xi2.html and then browsing down and up worked
ξ 8) very very strange, perhaps something to do with index.html in folders, anyhow name files according to the naming systems being used!
ξ 9) Windows 8.1 offered some challenges too, not forgetting browsers

Actions:
ξ test2twentyfour has both solar (new) and bio energy because it was the solar energy beihing causing the problems!
ξ 1) Enceladus as backup 1 for all tests ( 32,274 files!), 9912 folders(!), 700 Mb(!) and slower HD-GDU3 as backup 2
ξ 2) sense of test2twentyfour as sense of test2dragon and run shoot2dragon4uri5test
ξ
ξ 93 [ACK] ss
ξ 143 [ACK] web
ξ 845 [ACK] vc (venture capital) - Plone CMS folder (compability issue here!)
ξ 108 [ACK] design - well structured using well images and textual content provided by other folders!
ξ 752 [ACK] bp (business plan) - captured image to uri2dragon4yo.html - very complicated structure with lot of links!
ξ 623 [ACK] brand - several layer structure due to Plone CMS!
ξ 1627 [ACK] UAS and UAG - verified URI having container domains design, web, vc, brand, bp and spec to supoort references!
ξ verified xi folder in UAS sensing, which actually contains specifications based on collaboration with one vendor being hardest to verify!
ξ removed URL references with null internet access i.e. the ones made ready for future, because it is a bad idea from verifying URI point of view!
ξ added extensions to be opened, succeeded to test opening new kind of content such as pdf documents and emails
ξ added feature which allows to focus only to one or few folders such as sense during testing, while other folders just provide content to be referred
ξ icewaves spec copied thereby loosing wiki changes, on the other hand getting more normal hyperlinks
ξ copied simusite to test2dragon to have content to refer for sensed domains such as UAS
ξ added domains based on ROOT:\DRAGONXI\WebFaction\Web306\FTPWeb306\home\icefellow\webapps\yodragonxiorg
ξ had test2master as the test2dragon, UAS missing and therefore index-sense-xi2.html modified not to refer to it!
ξ having test data speaed to several hard disks is demanding but also makes concurrent working locally and with web via FTP more efficient!
ξ explored complicated references to Wiki!
ξ tested domains URI (USA are China are not domain) tested / FTP uploaded / yosense backups taken locally
ξ testing URI revealed bugs in URL references where URL had been forgotten!
ξ decided to run automate2ref4uri testing URI in all to verify module testing and to achieve state where only URL links may need updating
ξ realized when programming dragon module you always have to remember to name variables to xxxxxxxx2yyyyyyyy4dragon for software generation phase!
ξ hit aero ../../../sense/aero/rw/us/en-us-rw-aero-xi2.html kind of URI references!
ξ tested biz which also revealed how newspapers have disappeared and lost markets to digital media
ξ added alarms if there are failures to verify a file
ξ added more internet procols such as ftp and mailto not to be opened but skipped
ξ discovred that mobile industry is even more mobile than software one - companies get merged or bankgrupted in alarming speed!
ξ tested software, software industry is the one where even big names get busted with all ecosystems i.e. small subvendors!
ξ started UAS tests - hit the fact it refers to many domainds such as specifications!
ξ kept test status in version4xi.py (search automate2ref4uri.py) - selected test2two (arts)
ξ hit the tendence to refer to too complicated and detailed URLs!
ξ modified chinese web pages references only to refer to chinese main page, not to english ones!
ξ hit the Plone decision to replace _ with - in a newer version which cause a lot of headache with CMS, now here!
ξ found lucky to have get and put for U.S and China content!
ξ uploaded test environments to server where downloaded to other workstations to test in several machines
ξ »shoot2dragon4uri5test ξ »shoot2dragon4uri ξ »version4xi
ξ »DragonTest SENSE (Rp) »DragonTest SENSE (Fb)
ξ ack2debug4dragon reviewed, no effect to logic anymore, debug data was correct because copy and paste was used to create it
ξ »PROGRAM2URI4YO ξ »URI2TEST4YO

Backup
ξ Saturn (1) Titan (2) Enceladus (3) Phoebe(4) Haumes (5) / FTP upload tests

April 17, 2015
ξ J:\temp\yosense\test2generate4server\dragon <-- to create test2dragon
ξ J:\temp\yosense\test2generate4server\33 <-- to create test2hirtythree
ξ ...
ξ J:\temp\yosense\test2generate4server\00 <-- to create test2zero
ξ F:\temp\yosense\test2dragon <-- to run shoot2dragon4uri5test.py
ξ U:\temp\yosense <-- test data backup in USB disk
ξ H:\Backup\temp\yosense <-- test data backup in hard disk
ξ \home\icefellow\webapps\yodragonxiorg\web\test <-- test data in server for testing in different systems
ξ »URI2TEST4YO <-- tests
ξ »URI2TEST4YO <-- tests

April 16, 2015
ξ »automate2ref4uri.py
ξ »shoot2dragon4uri.py
ξ »generate2shoot4uri.py
ξ »generate2gun4uri.py
ξ serious challenge - stopped to create HTML output files, because gun modules were not being generated at all!
ξ generate2gun4uri.py settings were those used to generate code for Scope4Xi!

April 1, 2015
ξ URI continued - more energy subdomains added!!
ξ [URI]: 54574 [ACK] - corrected index level files in design, spec ...
ξ [URI]: 4793 [ACK] - new energy - browser tests will reveal if some still will be missing!

Fastblack (big enough hard disks to have more domains):
ξ 54222 [ACK]
ξ kbfocus2uri4dragon [1] = 'sense' #[ACK] <-- not all subdomains!
ξ kbfocus2uri4dragon [2] = 'bp' #[ACK]
ξ kbfocus2uri4dragon [3] = 'brand' #[ACK]
ξ kbfocus2uri4dragon [4] = 'design' #[ACK]
ξ kbfocus2uri4dragon [5] = 'nda' #[ACK]
ξ kbfocus2uri4dragon [6] = 'ss' #[ACK]
ξ kbfocus2uri4dragon [7] = 'vc' #[ACK]
ξ kbfocus2uri4dragon [8] = 'web' #[ACK]
ξ kbfocus2uri4dragon [9] = 'spec' #[ACK]
ξ kbfocus2uri4dragon [10] = 'stock4xi' #[ACK]
ξ kbfocus2uri4dragon [11] = 'sw4xi' #[ACK]
ξ kbfocus2uri4dragon [12] = 'scope4xi' #[ACK]
ξ kbfocus2uri4dragon [13] = 'studio4xi' #[ACK]

RiikaPC (due to smaller hard disks only the most important sw4xi, studio4xi and scope4xi versions supported in test2dragon):
»uri2dragon4yo
»shoot2dragon4uri
ξ 43524 [ACK] <-- sw4xi[3.3 and 3.2]/studio4xi[3.1 and 3.2]/scop4xi[041721] 43524 [ACK]

March 30, 2015
»uri2dragon4yo
»shoot2dragon4uri
ξ writes to uri2dragon4yo.html in URI test if there is a URL reference without missing end (although URL type)
ξ halongbay [URI]: 1799 [ACK] / 13687 [NACK]*** [URL]: 4 [NACK] *** <-- \pc4xi\comdragonxi\website <=> www.dragonxi.com Plone site
ξ 1-13 [URI]: 54222 [ACK] /
ξ icewaves [URI]: 15190 [ACK] /3 [NACK]*** [URL]: 1[NACK]*** <-- icewaves//0001//bp//bp_ref.html
ξ studio4xi [URI]: 21295 [ACK] /[URL]:
ξ scope4xi [URI]: 2295 [ACK] /[URL]:
ξ sw [URI]: 10883 [ACK] /[URL]:
ξ spec [URI]: 12645 [ACK] /[URL]:
ξ web [URI]: 143 [ACK] /[URL]:
ξ vc [URI]: 845 [ACK] /[URL]: 1 [NACK] *** <-- vc//bp//xi//bp_ref.html
ξ ss [URI]: 93 [ACK] /[URL]:
ξ design [URI]: 208 [ACK] /[URL]:
ξ brand [URI]: 623 [ACK] /[URL]:
ξ sense [URI]: 4440 [ACK] /[URL]: 2 [NACK] *** <-- en-org-hydro-xi2.html
ξ bp [URI]: 751 [ACK] /[URL]: 1 [NACK] *** <-- bp_ref.html (missing end)

March 28, 2015
ξ 54222 [ACK] <-- 13 domains!
ξ 21295 [ACK] <-- studio4xi as a new one alone!
ξ 2292 [ACK] <-- scope4xi as a new one alone!
ξ 10883 [ACK] <-- sw4xi as a new one alone!
ξ 19749 [ACK] <-- all (icewaves not verified in this case)
ξ 15187 [ACK] <-- icewaves included which required certain menu scipt files to be skipped!
ξ 19749 [ACK] <-- stock4xi included!
ξ 19744 [ACK] <-- all sensed!
ξ 12640 [ACK] <-- spec alone!
ξ 4440 [ACK] <-- test2master sense <=> URI verfication to ALL domains (below sets tested first separately))

RiikaPC
»uri2dragon4yo
ξ 4755 [ACK] <-- test2master sense <=> URI verfication to ALL domains (below sets tested first separately)

»"file:///M:/temp/yosense/test2zero/uri2zero4yo.html" target="_blank">uri2zero4yo ,»"file:///M:/temp/yosense/test2one/uri2one4yo.html" target="_blank">uri2one4yo ,»"file:///M:/temp/yosense/test2two/uri2two4yo.html" target="_blank">uri2two4yo ,»"file:///M:/temp/yosense/test2three/uri2three4yo.html" target="_blank">uri2three4yo ,»"file:///M:/temp/yosense/test2four/uri2four4yo.html" target="_blank">uri2four4yo ,»"file:///M:/temp/yosense/test2five/uri2five4yo.html" target="_blank">uri2five4yo ,»"file:///M:/temp/yosense/test2six/uri2six4yo.html" target="_blank">uri2six4yo ,»"file:///M:/temp/yosense/test2seven/uri2seven4yo.html" target="_blank">uri2seven4yo ,»"file:///M:/temp/yosense/test2eight/uri2eight4yo.html" target="_blank">uri2eight4yo ,»"file:///M:/temp/yosense/test2nine/uri2nine4yo.html" target="_blank">uri2nine4yo
»"file:///M:/temp/yosense/test2ten/uri2ten4yo.html" target="_blank">uri2ten4yo ,»"file:///M:/temp/yosense/test2eleven/uri2eleven4yo.html" target="_blank">uri2eleven4yo ,»"file:///M:/temp/yosense/test2twelve/uri2twelve4yo.html" target="_blank">uri2twelve4yo ,»"file:///M:/temp/yosense/test2thirteen/uri2thirteen4yo.html" target="_blank">uri2thirteen4yo ,»"file:///M:/temp/yosense/test2fourteen/uri2fourteen4yo.html" target="_blank">uri2fourteen4yo ,»"file:///M:/temp/yosense/test2fifteen/uri2fifteen4yo.html" target="_blank">uri2fifteen4yo ,»"file:///M:/temp/yosense/test2sixteen/uri2sixteen4yo.html" target="_blank">uri2sixteen4yo ,»"file:///M:/temp/yosense/test2seventeen/uri2seventeen4yo.html" target="_blank">uri2seventeen4yo ,»"file:///M:/temp/yosense/test2eighteen/uri2eighteen4yo.html" target="_blank">uri2eighteen4yo ,»"file:///M:/temp/yosense/test2nineteen/uri2nineteen4yo.html" target="_blank">uri2nineteen4yo ,»"file:///M:/temp/yosense/test2twenty/uri2twenty4yo.html" target="_blank">uri2twenty4yo
»"file:///M:/temp/yosense/test2twentyone/uri2twentyone4yo.html" target="_blank">uri2twentyone4yo ,»"file:///M:/temp/yosense/test2twentytwo/uri2twentytwo4yo.html" target="_blank">uri2twentytwo4yo ,»"file:///M:/temp/yosense/test2twentythree/uri2twentythre4yo.html" target="_blank">uri2twentythre4yo ,»"file:///M:/temp/yosense/test2twentyfour/uri2twentyfour4yo.html" target="_blank">uri2twentyfour4yo ,»"file:///M:/temp/yosense/test2twentyfive/uri2twentyfive4yo.html" target="_blank">uri2twentyfive4yo ,»"file:///M:/temp/yosense/test2twentysix/ uri2twentysix4yo.html" target="_blank">uri2twentysix4yo ,»"file:///M:/temp/yosense/test2twentyseven/uri2twentyseven4yo.html" target="_blank">uri2twentyseven4yo ,»"file:///M:/temp/yosense/test2twentyeight/uri2twentyeight4yo.html" target="_blank">uri2twentyeight4yo ,»"file:///M:/temp/yosense/test2twentynine/uri2twentynine4yo.html" target="_blank">uri2twentynine4yo ,»"file:///M:/temp/yosense/test2thirty/uri2thirty4yo.html" target="_blank">uri2thirty4yo
»"file:///M:/temp/yosense/test2thirtyone/uri2thirtyone4yo.html" target="_blank">uri2thirtyone4yo ,»"file:///M:/temp/yosense/test2thirtytwo/uri2thirtytwo4yo.html" target="_blank">uri2thirtytwo4yo ,»"file:///M:/temp/yosense/test2thirtythree/uri2thirtythree4yo.html" target="_blank">uri2thirtythree4yo

Backup (daily): Titan/ HD-GDU3 /FTP/ INNOVATION /Ceres

March 9, 2015
ξ »DragonTest SENSE (Rp) »DragonTest SENSE (Fb)
ξ »Hardware sensing (Rp) »Hardware sensing (Fb)

ξ »shoot2dragon4uri5test »version4xi
ξ hw(9) and sports(20) - tested URI and URL - copied to test2master/test2nine/test2twenty

ξ »shoot2dragon4uri
ξ corrected a very dangerous bug where trace debugging caused error in logic (with embedded dragonized trace it is avoided)
ξ if ack2debug4dragon is True: <-- normal trace is based on using logic and can be very dangerous!
ξ set to test only URI which is wise in the first phase
ξ cleaned trace for »automate2ref4uri
ξ added URI and ULR statistics [ACK] and [NACK] both for each file checked and for all checked one
ξ increased relative level up to eight(8)
ξ »uri2dragon4yo (Rp) »uri2dragon4yo (Fb)
ξ hardware and sports sensing in focus
ξ decided to have in test2master all dragon tested and corrected files

Backup
ξ All Daily/ All Dragon /FTP (Studio4Xi, test2dragon) /

March 8, 2015
ξ started to use the same test2dragon in different workstations
ξ »SENSE (local)
ξ »Hardware sensing (local)
ξ hardware focus only (test2nine)
ξ »shoot2dragon4uri
ξ URLs improved
ξ revealed that source HTMl files such as en-zj-cn-hw-xi2.html have empty URI/URL which must be removed
ξ ../../index-hw-xi2.html handled
ξ pattern2ext4dragon, pattern2hyper4dragon, profile2fetch4dragon changed to dictionaries to handle various types
ξ ack2urltest4dragon = False # <-- no URL tests
ξ ack2uricheck4dragon = False # <-- tell only about wrong URI references
ξ ack2urlwarn4dragon = False # <-- no URLs skipped warnings
ξ tested URI references in hardware sensing getting good results
ξ FTP uploaded /yosense/test2dragon/sense test configuration to be downloaded to FastBlack workstation

Backup
ξ All / DragonXi / FTP (Studio4Xi, test2dragon) /

March 5, 2015
ξ updated minimized index-sense-xi2.html to 1 ... 33 test folders!
»Special SENSE for Dragon
ξ edited based on each dragon test!
ξ »SENSE PC
ξ model - do NOT touch this!

ξ browser bug: if you first click URI report, thereby click file verified and then click return, browser fails to build return URI!
ξ browser use: go to file browser, click HTMl file and use it as it is, then URI links will work if they are ok!
ξ »shoot2dragon4uri5test »shoot2dragon4uri
ξ if count2ultimate4dragon > index2stop4dragon: <-- if count2ultimate4dragon > index2stop4dragon + 1:
ξ URI up is built ok with above change!
ξ added reporting failed URI's to lower levels
ξ F://temp//yosense//test2dragon//e/index-e-xi2.html [NACK] <-- bug: sense// missing!
ξ added usage instructions
ξ up URI generated bug, for example file:///F://temp//yosense//test2eleven//sense//marine//us//ak//en-us-marine-xi2.html
ξ correct one file:///F://temp//yosense//test2eleven//sense//marine//us//en-us-marine-xi2.html
ξ add final cleaning for URI by taking omitting the current subdomain in its path, if any
ξ Verifying URIs in �F://temp//yosense//test2eleven//sense\marine\jp\en\en-jp-marine-xi2.html <-- click ok and return ok with browser!
ξ [URI]: �F://temp//yosense//test2eleven//sense//marine//jp//../index-marine-xi2.html [ACK] <-- openened ok, click naturally not ok!
ξ corrected to report hyperlink ONLY to the files tested whereas for URI it just gives its name!
ξ »PROGRAM2URI4YO »URI2TEST4YO »CONTENT2URI4YO

Backup
ξ Enceladus (1) Phoebe (2) HD-GDU3 (*)/

March 4,3, 2015
»automate2ref4uri
ξ second run testing only URI (ack2debug4dragon = False )
ξ first run used internet heavily to verify URLs - demonstrated the importance of multiprocessing4xi!

ξ »shoot2dragon4uri5test
ξ F:\temp\test2dragon4all\sense <-- created to feed F:\temp\yosense\test2dragon
ξ »Space Sensing of WY
ξ bug revealed by shoot2dragon4uri.py: «Space Sensing

ξ »shoot2dragon4uri
ξ F:\temp\test2dragon4all\sense <-- created to feed F:\temp\yosense\test2dragon
ξ added URL test as an option because they take so much time!
ξ top level tests (J:\temp\yosense\test2master in FB - files/folders copied one at a time to F:\temp\yosense\test2dragon
ξ [nack] index-sense-xi2.html with subfolders <-- focus; good results !
ξ »shoot2dragon4uri5test
ξ used browser to make sure right levels are defined - added sense folder and index.html as home to right levels to all!
ξ F:\temp\yosense\test2dragon\index.html <-- main corresponding the one in www.yourdragonxi.org
ξ F:\temp\yosense\test2dragon\sense\index-sense-xi2.html <-- sense folder as in the web page and its main page
ξ othetr HTML files missing in the beginning
ξ [ack] index2china4yo.html - passwords not given therefore it did not try to open
ξ [ack] index_temp.html [WEB URL]: �https://www.yourdragonxi.com [ACK]
ξ [ack] just index.html files to be walked
ξ warning given about URLs with password - not even own URLs openend with password not to reveal it!
ξ hit the fact that you can change max one (1) line to avoid total disaster when dealing with URLs!
ξ Python URL lib is a landmine with a lot of bugs
ξ have to consider whether to check ULRs at all or stop checking once one problem is hit!
ξ news4yo.html as test data - one bug found in it and corrected - aced it!
ξ no retrialsto open web URL because of poor quality of the services provided by Python url-libraries !
ξ upgraded shoot2dragon4uri.py not to check the HTML file uri2dragon4yo.html, which is produced by itself

Programs for URI
ξ »shoot2dragon4uri5test ,ξ »shoot2dragon4uri ,ξ »automate2ref4uri ,ξ »gun2dragon4uri ,ξ »version4xi ,ξ »generate2gun4uri ,ξ »generate2shoot4uri
ξ »gun2one4uri ... »gun2thirtythree4uri
ξ »shoot2one4uri ... »shoot2thirtythree4uri

Test Data
FastBlack:
»"file:///F:/temp/yosense/test2dragon/index-sense-xi2.html" target="_blank">SENSE ,»"file:///F:/temp/yosense/test2dragon/index2usa4yo.html" target="_blank">USA ,»"file:///F:/temp/yosense/test2dragon/index2org4yo.html" target="_blank">ORG ,»"file:///F:/temp/yosense/test2dragon/index2eu4yo.html" target="_blank">EU ,»"file:///F:/temp/yosense/test2dragon/index2country4yo.html" target="_blank">COUNTRY ,»"file:///F:/temp/yosense/test2dragon/index2china4yo.html" target="_blank">CHINA ,»"file:///F:/temp/yosense/test2dragon/index_temp.html" target="_blank">temp ,»"file:///F:/temp/yosense/test2dragon/index.html" target="_blank">index (home) <-- must be verified!
RiikaPC:
»"file:///L:/temp/yosense/test2dragon/index-sense-xi2.html" target="_blank">SENSE ,»"file:///L:/temp/yosense/test2dragon/index2usa4yo.html" target="_blank">USA ,»"file:///L:/temp/yosense/test2dragon/index2org4yo.html" target="_blank">ORG ,»"file:///L:/temp/yosense/test2dragon/index2eu4yo.html" target="_blank">EU ,»"file:///L:/temp/yosense/test2dragon/index2country4yo.html" target="_blank">COUNTRY ,»"file:///L:/temp/yosense/test2dragon/index2china4yo.html" target="_blank">CHINA ,»"file:///L:/temp/yosense/test2dragon/index_temp.html" target="_blank">temp ,»"file:///L:/temp/yosense/index.html" target="_blank">index (home) <-- must be verified!

Verification
»uri2test4yo
»version4xi
ξ search automate2ref4uri.py and see test folders (may locate if different drives)

Backup
ξ March 4: Saturn (1) Titan (2)/ (FTP / INNOVATION / Ceres)

February 28, 2015
ξ »automate2ref4uri
ξ ack2trace = False, succeeded to run with results showing also lower level links!
ξ »shoot2dragon4uri5test »shoot2dragon4uri
ξ »uri2dragon4yo (local)
ξ upgraded to offer hyperlink to the one opened/closed and to the caller
ξ «SENSE <-- OK hyperlink in HTML file!
ξ file:///F://temp//yosense//test2dragon//xx//index-sense-xi2.html <-- wrong hyperlink built by shoot2dragon4uri.py
ξ «SENSE <-- hyperlink ok in FINAL folder, NOT in xx folder!
ξ (2) ../sense/e/index-e-xi2.html <-- yes, reported as error!
ξ yes, built hyperlink to ../sense/e/index-e-xi2.html and reported return from index-e-xi2.html
ξ (3) e/index-e-xi2.html <-- trying to get it NOT to skip this kind of hyperlinks to lower levels!
ξ added pattern2href4dragon and pattern2http4dragon
ξ (3) final2lowleveluri4dragon = begin2lowlevel4dragon + rest2lowleveluri4dragon
ξ (4) succeeded to print and write URI to lower level URIs - does not try to open them yet

Verification
ξ »URI2TEST4YO

Backup (daily): Enceladus(1), Phoebe(2), Theia (3), Haumes(4) / FTP /

February 27, 2015
ξ »shoot2dragon4uri5test
ξ changed default not to print trace because it disturbs module testing shoot2dragon4uri.py
ξ »shoot2dragon4uri
ξ updated dragon2shoot4uri5test.bat to first delete F:\temp\yosense\test2dragon\uri2dragon4yo.html
ξ decided to handle all possible combinations of URI (aaargh)!
ξ upgraded to print modified paths in the beginning and swaps the modified one to target2explore4dragon
ξ updated input to correspond structure in the web and to that uploaded with FTP
ξ solved the wrong error message mystery
ξ discovered that verify2ref4dragon function reports rightly errors in modules locating in \xx folder !
ξ \xx folder is being to get and put HTML files from other folders !
ξ lesson: wrong and bad test data may lead to erroneous conclusions about software logic!

browser tests:
ξ L://temp//yosense//test2dragon//xx\index-aero-xi2.html <-- IE, Safari and Fox do NOT handle it!
ξ L://temp//yosense//test2dragon//xx//index-aero-xi2.html <-- Opera, Chrome DO even correct whereas IE, Fox, Safari DON'T!

Backup (daily): Saturn, Titan / HD-GDU3 /FTP/ KING, FREEDOM/

February 26, 2015
ξ »automate2ref4uri
ξ generated the Results below
ξ »shoot2dragon4uri5test
ξ one level tested, added aero as the second level
ξ »shoot2dragon4uri
ξ hit the challenge to handle local Windows hybrid URI types containing both // and \
ξ programmed to handle special URIs (../sense/index2country4yo.html) existing due to browser bugs
ξ upgraded statistics »uri2dragon4yo (local)
ξ reported in HTML statistics Plone CMS type of URI errors such as ../index-sense-xi2/
ξ switched standard debugging on/off by setting ack2debug4dragon in shoot2dragon4uri.py
ξ discovered that generated code is as good as its master input i.e. upgraded automate2ref4uri.bat as follows:
ξ - copy shoot2dragon4uri.py E:\temp\dragonize\in <-- automatically copies the latest source
ξ - copy gun2dragon4uri.py E:\temp\dragonize\in <-- automatically copies the latest source

February 25, 2015
ξ »shoot2dragon4uri5test
ξ tested shoot2dragon4uri
ξ index.html added to /temp/yosense folders because it is referred by index-sense-xi2.html in each test
ξ more necessary html files added to root level /temp/yosense
ξ »gun2dragon4uri
ξ worked
ξ »shoot2dragon4uri
ξ upgraded, was able to process index-sense-xi2.html files with hyperlink ../index.html
ξ decided to skip hyperlinks traversing up and down in source HTMl files such as index-sense-xi2.html
ξ reason to those hyperlinks lies in different browser versions unable to handle hyperlinks referring to subfolders!
ξ »version4xi
ξ changes test file path, F://temp//yosense//test2dragon// <-- F://temp//sense//test2dragon//
ξ »"file:///F:/temp/yosense/test2dragon/index2xxxxxxxx4yo.html" target="_blank">index2xxxxxxxx4yo.html (local)

Backup (daily): Saturn/ HD-GDU3 /FTP/ INNOVATION /Ceres

February 24, 2015
Main actors:
ξ »automate2ref4uri »gun2dragon4uri »shoot2dragon4uri »version4xi

Generators called:
ξ »generate2gun4uri »generate2shoot4uri

Modules generated and their functions imported:
ξ »gun2one4uri
...
ξ »gun2thirtythree4uri
ξ »shoot2one4uri
...
ξ »shoot2thirtythree4uri

Data for test:
J:\temp\yosense\test2master\ # [ACK] Sun (master used by automate2ref4uri.py only)
F:\temp\yosense\test2dragon\ # [ACK] Saturn (base for 1 ... 33)

#dynamic-start
D:\temp\yosense\test2zero\ # [ACK] Eris
G:\temp\yosense\test2one\ # [ACK] Titan
H:\temp\yosense\test2two\ # [ACK] Enceladus
I:\temp\yosense\test2three\ # [ACK] Phoebe
K:\temp\yosense\test2four\ # [ACK] Theia
L:\temp\yosense\test2five\ # [ACK] Haumea
M:\temp\yosense\test2six\ # [ACK] Logic
N:\temp\yosense\test2seven\ # [ACK] Venus
O:\temp\yosense\test2eight\ # [ACK] Jupiter
P:\temp\yosense\test2nine\ # [ACK] Kelvin
Q:\temp\yosense\test2ten\ # [ACK] Taiko
F:\temp\yosense\test2eleven\ # [ACK] Saturn
G:\temp\yosense\test2twelve\ # [ACK] Titan
M:\temp\yosense\test2thirteen\ # [ACK] Logic
K:\temp\yosense\test2fourteen\ # [ACK] Theia
L:\temp\yosense\test2fifteen\ # [ACK] Haumea
M:\temp\yosense\test2sixteen\ # [ACK] Logic
N:\temp\yosense\test2seventeen\ # [ACK] Venus
O:\temp\yosense\test2eighteen\ # [ACK] Jupiter
P:\temp\yosense\test2nineteen\ # [ACK] Kelvin

Q:\temp\yosense\test2twenty\ # [ACK] Taiko
F:\temp\yosense\test2twentyone\ # [ACK] Saturn
G:\temp\yosense\test2twentytwo\ # [ACK] Titan
I:\temp\yosense\test2twentythree\ # [ACK] Phoebe
K:\temp\yosense\test2twentyfour\ # [ACK] Theia
L:\temp\yosense\test2twentyfive\ # [ACK] Haumea
M:\temp\yosense\test2twentysix\ # [ACK] Logic
N:\temp\yosense\test2twentyseven\ # [ACK] Venus
O:\temp\yosense\test2twentyeight\ # [ACK] Jupiter
P:\temp\yosense\test2twentynine\ # [ACK] Kelvin

Q:\temp\yosense\test2thirty\ # [ACK] Taiko
F:\temp\yosense\test2thirtyone\ # [ACK] Saturn
G:\temp\yosense\test2thirtytwo\ # [ACK] Titan
M:\temp\yosense\test2thirtythree\ # [ACK] Logic
#dynamic-end

Data in test:
»pcSENSE
»yoSENSE
ξ all relative hyperlinks should be ok

Configuration in FastBlack:
ξ as before, because you do NOT have xcopy command available in Windows 8.1!
ξ restored from recycle bin previously created test data!

Backup (daily): Uranus / FTP

Configuration in RiikaPC :
ξ »version2riika4xi
ξ M:\temp\yosense\create2test4xi.bat <--> creates M:\temp\yosense\test2zero ... M:\temp\yosense\test2thirtythree
ξ M:\temp\yosense\create2index4sense.bat <--> populates index-sense-xi2.html to test folders
ξ L:\temp\yosense\test2master\copy2domain4test.bat <-> copies test data to M:\temp\yosense\test2zero ... test2thirtythree
ξ used above batch files (copy exists in bat folder) to create/recreate test data instead of doing it manually

Test data in RiikaPC :
ξ L:\temp\yosense\test2master
ξ L:\temp\yosense\test2dragon
ξ M:\temp\yosense\test2one ... M:\temp\yosense\test2thirtythree

Backup (daily) in RiikaPC: INNOVATION/Ceres / FTP

February 23, 2015

Main actors:
ξ »automate2ref4uri »gun2dragon4uri »shoot2dragon4uri »version4xi
ξ to walk local html files and try to open hyperlinked html file thereby verifying local hyperlinks
ξ designed test data

Generators called:
ξ »generate2gun4uri »generate2shoot4uri

Modules generated and their functions imported:
ξ »gun2one4uri
...
ξ »gun2thirtythree4uri
ξ »shoot2one4uri
...
ξ »shoot2thirtythree4uri

Data for test:
J:\temp\yosense\test2master\ # [ACK] Sun (master used by automate2ref4uri.py only)
F:\temp\yosense\test2dragon\ # [ACK] Saturn (base for 1 ... 33)

#dynamic-start
D:\temp\yosense\test2zero\ # [ACK] Eris
G:\temp\yosense\test2one\ # [ACK] Titan
H:\temp\yosense\test2two\ # [ACK] Enceladus
I:\temp\yosense\test2three\ # [ACK] Phoebe
K:\temp\yosense\test2four\ # [ACK] Theia
L:\temp\yosense\test2five\ # [ACK] Haumea
M:\temp\yosense\test2six\ # [ACK] Logic
N:\temp\yosense\test2seven\ # [ACK] Venus
O:\temp\yosense\test2eight\ # [ACK] Jupiter
P:\temp\yosense\test2nine\ # [ACK] Kelvin
Q:\temp\yosense\test2ten\ # [ACK] Taiko
F:\temp\yosense\test2eleven\ # [ACK] Saturn
G:\temp\yosense\test2twelve\ # [ACK] Titan
M:\temp\yosense\test2thirteen\ # [ACK] Logic
K:\temp\yosense\test2fourteen\ # [ACK] Theia
L:\temp\yosense\test2fifteen\ # [ACK] Haumea
M:\temp\yosense\test2sixteen\ # [ACK] Logic
N:\temp\yosense\test2seventeen\ # [ACK] Venus
O:\temp\yosense\test2eighteen\ # [ACK] Jupiter
P:\temp\yosense\test2nineteen\ # [ACK] Kelvin

Q:\temp\yosense\test2twenty\ # [ACK] Taiko
F:\temp\yosense\test2twentyone\ # [ACK] Saturn
G:\temp\yosense\test2twentytwo\ # [ACK] Titan
I:\temp\yosense\test2twentythree\ # [ACK] Phoebe
K:\temp\yosense\test2twentyfour\ # [ACK] Theia
L:\temp\yosense\test2twentyfive\ # [ACK] Haumea
M:\temp\yosense\test2twentysix\ # [ACK] Logic
N:\temp\yosense\test2twentyseven\ # [ACK] Venus
O:\temp\yosense\test2twentyeight\ # [ACK] Jupiter
P:\temp\yosense\test2twentynine\ # [ACK] Kelvin

Q:\temp\yosense\test2thirty\ # [ACK] Taiko
F:\temp\yosense\test2thirtyone\ # [ACK] Saturn
G:\temp\yosense\test2thirtytwo\ # [ACK] Titan
M:\temp\yosense\test2thirtythree\ # [ACK] Logic
#dynamic-end

Data in test:
»pcSENSE
»yoSENSE
ξ all relative hyperlinks should be ok

Backup (daily): Venus / FTP

February 19, 2015
ξ »find2html4dragon
ξ used to find Plone CMS object-hyperlinks in sensing to change them to traditional HTML-hyperlinks
ξ for example: ../../index-edu-xi2/ <-- ../../index-edu-xi2.html/
ξ »yoSENSE

February 17, 2015

Main actors:
ξ »automate2analyse4xi
ξ explored code inside #dynamic-start and #dynamic-end blocks
ξ puts dynamically command and control messages copy2thirteen ... copy2thirtythree
ξ sends dynamically copy2thirteen ... copy2thirtythree
ξ generates code dynamically by calling generate2gun4search and generate2shoot4search
ξ imports in static way the generated functions: from gun2thirteen4search import gun2thirteen4search
ξ saves imported gun functions to be used as target functions for processes: DirectionKB4Xi[direction2xi] ['function2target'] = gun2thirteen4search
ξ only imports shoot functions to make sure target functions will succeed importing them: from shoot2thirteen4search import shoot2thirteen4search
ξ manages multiprocessing4xi dynamically by using DirectionKB4Xi
ξ »version4xi
ξ fastblack workstation version
ξ »version2riika4xi
ξ riikapc workstation version
ξ »parsestudio4xi.py
ξ abondeded idea to add dynamic as a tag because it is not a verb
ξ parsed totally 36 tags in : 57 modules

Generators called:
ξ »generate2gun4search
ξ »generate2shoot4search

Modules generated and their functions imported:
ξ »gun2thirteen4search
...
ξ »gun2thirtythree4search
ξ »shoot2thirteen4search
...
ξ »shoot2thirtythree4search

Image data for test:
ξ the same as February 16, 2015

Directions in web:
ξ the same as February 16, 2015

Integrated in web:
»index2walk4yo
»[A] cam@Photos
»[A] large@Photos
»[A] medium Photos
...
»[Z] cam@Photos
»[Z] large@Photos
»[Z] medium Photos

Backup (daily): Logic,HD-GUF / FTP / Ceres

February 16, 2015

Main actors:
ξ »automate2analyse4xi »version4xi

Generators called:
ξ »generate2gun4search »generate2shoot4search

Modules generated and their functions imported:
ξ »gun2thirteen4search
...
ξ »gun2thirtythree4search
ξ »shoot2thirteen4search
...
ξ »shoot2thirtythree4search

Image data for test (location depends on workstation):
J://temp//yophotos//test2master//', # [ACK] Sun (master photos used by analyse2photo4search.py only)
# Full medium/large/cam or subset (preferred)
F://temp//yophotos//test2dragon//', # [ACK] Saturn
D://temp//yophotos//test2zero//', # [ACK] Eris (Assets)
G://temp//yophotos//test2one//', # [ACK] Titan (+Catch,+Scene,+Timing)
H://temp//yophotos//test2two//', # [ACK] Enceladus (+Catch,-Scene,-Timing)
I://temp//yophotos//test2three//', # [ACK] Phoebe (+Catch,+Scene,-Timing)
K://temp//yophotos//test2four//', # [ACK] Theia (+Catch,-Scene,+Timing)
L://temp//yophotos//test2five//', # [ACK] Haumea (-Catch,+Scene,+Timing)
M://temp//yophotos//test2six//', # [ACK] Logic (-Catch,+Scene,-Timing)
N://temp//yophotos//test2seven//', # [ACK] Venus (-Catch,-Scene,+Timing)
O://temp//yophotos//test2eight//', # [ACK] Jupiter (-Catch,-Scene,-Timing)
P://temp//yophotos//test2nine//', # [ACK] Kelvin (September)
Q://temp//yophotos//test2ten//', # [ACK] Taiko (October)
F://temp//yophotos//test2eleven//', # [ACK] Saturn (Shotgun)
G://temp//yophotos//test2twelve//', # [ACK] Titan (Rifle)
#dynamic-start
M://temp//yophotos//test2thirteen//', # [ACK] Logic (Bad)
K://temp//yophotos//test2fourteen//', # [ACK] Theia (Friends)
L://temp//yophotos//test2fifteen//', # [ACK] Haumea (Morning)
M://temp//yophotos//test2sixteen//', # [ACK] Logic (Mist)
N://temp//yophotos//test2seventeen//', # [ACK] Venus (Jani)
O://temp//yophotos//test2eighteen//', # [ACK] Jupiter (Marsh)
P://temp//yophotos//test2nineteen//', # [ACK] Kelvin (Nutrition)

Q://temp//yophotos//test2twenty//', # [ACK] Taiko (Duck)
F://temp//yophotos//test2twentyone//', # [ACK] Saturn (ACED IT!)
G://temp//yophotos//test2twentytwo//', # [ACK] Titan (Yhteismetsa)
I://temp//yophotos//test2twentythree//', # [ACK] Phoebe (Sarkat)
K://temp//yophotos//test2twentyfour//', # [ACK] Theia (Linnustus)
L://temp//yophotos//test2twentyfive//', # [ACK] Haumea (2000-2006)
M://temp//yophotos//test2twentysix//', # [ACK] Logic (Martinselkonen)
N://temp//yophotos//test2twentyseven//', # [ACK] Venus (2007)
O://temp//yophotos//test2twentyeight//', # [ACK] Jupiter (2003)
P://temp//yophotos//test2twentynine//', # [ACK] Kelvin (2009)

Q://temp//yophotos//test2thirty//', # [ACK] Taiko (Days 27,28,29,30,31)
F://temp//yophotos//test2thirtyone//', # [ACK] Saturn (2013)
G://temp//yophotos//test2thirtytwo//', # [ACK] Titan (2014)
M://temp//yophotos//test2thirtythree//', # [ACK] Logic (2012)

Directions in web:
»zero (Assets)
»one (+Catch,+Scene,+Timing)
Δ 1(+got it,+wilderness,+timed it) <=> nailed it all!
»two (+Catch,-Scene,-Timing)
Δ 2(+got it,-forestry,-timing not ideal) <=> got birds/rabit in spite of miserable scenes and bad timing!
»three (+Catch,+Scene,-Timing)
Δ 3(+got it,+wilderness,-timing not ideal) <=> got birds/rabit - even with bad timing - and enjoyed wilderness!
»four (+Catch,-Scene,+Timing)
Δ 4(+got it,-forestry,+timed it) <=> got birds/rabit timed although harvested forest!
»five (-Catch,+Scene,+Timing)
Δ 5(-missed it,+wilderness,!+timed it) <=> no catch in wilderness with ok timing!
»six (-Catch,+Scene,-Timing)
Δ 6(-missed it,+wilderness,!-timing not ideal)<=> no catch in wilderness and timing not ok!
»seven (-Catch,-Scene,+Timing)
Δ 7(-missed it,-forestry,+timed it) <=> no catch and bad forestry, only timing ok!
»eight (-Catch,-Scene,-Timing)
Δ 8(-missed it,-forestry,-timing not ideal) <=> failed it all!

»nine(September)
»ten(October)
»eleven(Shotgun)
»twelve(Rifle)
»thirteen(Bad)
»fourteen(Friends)
»fifteen(Morning)
»sixteen(Mist)
»seventeen(Jani)
»eighteen(Marsh)

»nineteen(Nutrition
»twenty(Duck)
»twentyone(ACED IT!)
»twentytwo(Yhteismetsa)
»twentythree(Sarkat)
»twentyfour(Linnustus)
»twentyfive(2000-2006)
»twentysix(Martinselkonen)
»twentyseven(2007)
»twentyeight(2003)
»twentynine(2009)

»thirty(Days 27,28,29,30,31)
»thirtyone(2013)
»thirtytwo(2014)
»thirtythree(2012)

Integrated in web:
»index2walk4yo

Backup (daily): Haumea,HD-GUF / FTP / Ceres

February 12, 2015

Main actors:
ξ »automate2analyse4xi »version4xi
ξ populated content for 15 ... 33 to be tailored

Generators called:
ξ »generate2gun4search »generate2shoot4search

Modules to generate and their functions to import:
ξ gun2fifteen4search.py .. gun2thirtythree4search.py
ξ shoot2fifteen4search.py ... shoot2thirtythree4search.py

Image data for test (location depends on workstation):
ξ folders test2thirteen ... test2thirtythree

Directions in web:
»thirteen2m4yo
»fourteen2m4yo
»fifteen2m4yo
»sixteen2m4yo
»seventeen2m4yo
»eighteen2m4yo
»nineteen2m4yo
»twenty2m4yo
»twentyone2m4yo
»twentytwo2m4yo
»twentythree2m4yo
»twentyfour2m4yo
»twentyfive2m4yo
»twentysix2m4yo
»twentyseven2m4yo
»twentyeight2m4yo
»twentynine2m4yo
»thirty2m4yo
»thirtyone2m4yo
»thirtytwo2m4yo
»thirtythree2m4yo

Integrated in web:
»index2walk4yo

Backup (daily): Theia,HD-GUF / FTP / HOPE, Ceres

February 11, 2015

Main actors:
ξ »automate2analyse4xi
ξ processed directions {13 ... 33} succeeded with dynamically generated code - stunning!
ξ »version4xi
ξ corrected path to direction 23 in fastblack

Generators called:
ξ »generate2gun4search »generate2shoot4search

Modules to generate and their functions to import:
ξ gun2fifteen4search.py .. gun2thirtythree4search.py
ξ shoot2fifteen4search.py ... shoot2thirtythree4search.py

Image data for test (location depends on workstation):
ξ folders test2fifteen ... test2thirtythree (dummy ones first)

Direction in web:
ξ none due to dummy test data

Integrated in web:
ξ none due to dummy test data

Backup (daily): Phoebe,HD-GUF / FTP / FREEDOM, Ceres

February 10, 2015

Main actors:
ξ »automate2analyse4xi
ξ created DirectionKB4Xi to loop directions 13 ... 33
ξ succeeded to create pipes with loop for directions 13 ... 33
ξ »version4xi
ξ added directions 15 ... 33, created test folders 15 ... 33

Generators called:
ξ »generate2gun4search »generate2shoot4search

Modules to generate and their functions to import:
ξ gun2fifteen4search.py .. gun2thirtythree4search.py
ξ shoot2fifteen4search.py ... shoot2thirtythree4search.py

Image data for test (location depends on workstation):
ξ folders test2fifteen ... test2thirtythree (dummy ones first)

Direction in web:
ξ none due to dummy test data

Integrated in web:
ξ none due to dummy test data

Backup (daily): Enceladus,HD-GUF / FTP / LOGIC, Ceres

February 9, 2015

Main actors:
ξ »automate2analyse4xi
ξ code between #dynamic-start ... #dynamic-end upgraded to handle directions fifteen (15) ... thirtythree (33)
ξ »version4xi
ξ added directions fifteen (15) ... thirtythree (33)

Generators called:
ξ »generate2gun4search »generate2shoot4search

Modules generated and their functions imported:
ξ »gun2fourteen4search
ξ »gun2thirteen4search
ξ to activate shoot function as dummy process
ξ »shoot2fourteen4search
ξ »shoot2thirteen4search
ξ to generate appropriate hyperlinks

Image data for test (location depends on workstation):
K:\temp\yophotos\test2fourteen <-- friends (Valentine's Day 14th of February)
ξ the concept friendship extended from guys to nature, food, sleep, rest, silence, boots, guns ...

Direction in web:
»fourteen2m4yo
ξ one image rotated - programs served also as quality control

Integrated in web:
»index2walk4yo

Backup (daily): Titan,HD-GUF / FTP / King,Ceres

February 6, 2015

Main actors:
ξ »automate2analyse4xi
ξ decided not to move generated programs to source folder because they are temporary and there might be many in future
ξ imported gun2thirteen4search and shoot2thirteen4search aftr having updated system path
ξ »version4xi
ξ no changes, only used as model how system path is checked and updated
ξ »test_gun4search.py
ξ tested that from gun2thirteen4search import gun2thirteen4search imports function whereas import gun2thirteen4search the module

Generators called by automate2analyse4xi:
ξ »generate2gun4search
ξ »generate2shoot4search
ξ both called by automate2analyse4xi.py allowing input for both to reside in the same folder

Modules generated and their functions imported by automate2analyse4xi:
ξ »gun2thirteen4search
ξ to activate shoot function as dummy process
ξ »shoot2thirteen4search
ξ to generate appropriate hyperlinks

Image data for test (location depends on workstation):
M:\temp\yophotos\test2thirteen <-- all went to bananas (13)

Direction in web:
»thirteen2m4yo

Integrated in web:
»index2walk4yo

Backup (daily): Saturn,HD-GUF/XXXXXXXX,Ceres/FTP

February 5, 2015

Main actors:
ξ »automate2analyse4xi
ξ established command and control pipe and queue
ξ added direction thirteen - marked with #dynamic-start and #dynamic-end
ξ called generate2gun4search and generate2shoot4search generating code for direction thirteen
ξ »version4xi
ξ added definitions for thirteen direction - marked with #dynamic-start and #dynamic-end

Generators called by automate2analyse4xi:
ξ »generate2gun4search
ξ »generate2shoot4search
ξ both called by automate2analyse4xi.py allowing input for both to reside in the same folder

Modules generated and to be transferred to their final source folder to be imported by automate2analyse4xi:
ξ »gun2thirteen4search
ξ to activate shoot function as dummy process
ξ »shoot2thirteen4search
ξ to generate appropriate hyperlinks

Image data for test (location depends on workstation):
M:\temp\yophotos\test2thirteen <-- all went to bananas (13)

Direction in web:
»thirteen2m4yo

Integrated in web:
»index2walk4yo

Backup (daily): Uranus,HD-GUF/KING,Ceres/FTP

February 4, 2015

ξ »automate2analyse4xi
ξ added direction eleven, twelve, nine and ten - marked with #dynamic-start and #dynamic-end
ξ »version4xi
ξ updated definitions for nine,ten,eleven and twelve directions

Code generated by analyse2photo4search.py:
ξ »gun2nine4search
ξ »gun2ten4search
ξ »gun2eleven4search
ξ »gun2twelve4search
ξ activated shoot function as dummy processes ok
ξ »shoot2nine4search
ξ »shoot2ten4search
ξ »shoot2eleven4search
ξ »shoot2twelve4search
ξ generated appropriate hyperlinks ok

Tailored generators:
ξ »generate2gun4search
ξ »generate2shoot4search
ξ generated code ok

Image data for test (depends on workstation):
L:\temp\yophotos\test2nine <-- september
L:\temp\yophotos\test2ten <-- october
F:\temp\yophotos\test2eleven and R://temp//yophotos//test2eleven// <-- Uranus <-- shotgun
G:\temp\yophotos\test2twelve and U://temp//yophotos//test2twelve// <-- HD-GDUR <-- rifle

Directions in web:
»nine2m4yo
»ten2m4yo
»eleven2m4yo
»twelve2m4yo

Integrated in web:
»index2walk4yo

Backup (daily): Venus,HD-GUF/KING,Ceres/FTP

February 2, 2015

Generated code by code to dynamically activate processes with automatically generated target functions
ξ »automate2analyse4xi
ξ to be tailored from analyse2photo4search.py
ξ »analyse2photo4search
ξ model for automate2analyse4xi.py
ξ »version4xi
ξ direction settings for shoot2eleven4search.py and shoot2twelve4search.py added

Code generators for directions eleven and twelve

Model for generators:
ξ »dragonize2studio4xi

Tailored generators:
ξ »generate2gun4search
ξ »generate2shoot4search
ξ base2build4dragon = VersionKB4Xi['base2shoot4dragon'] <-- required kb2keep[2] = "base2shoot4dragon"

Code generated by analyse2photo4search.py:
ξ »shoot2eleven4search
ξ »shoot2twelve4search
ξ »gun2eleven4search
ξ »gun2twelve4search

Input for generators (nb! one at a time!)
ξ E:\temp\dragonize\in\gun2dragon4search.py
ξ E:\temp\dragonize\in\shoot2dragon4search.py

Batch file to check that generated programs get compiled:
ξ run4xi.bat <-- compilation of generated programs revealed need to keep a dragon-string in generation
ξ kb2keep[2] = "base2shoot4dragon" <-- string to be kept

Image data to be created for test:
R://temp//yophotos//test2eleven// <-- Uranus <-- shotgun
U://temp//yophotos//test2twelve// <-- HD-GDUR <-- rifle

Directions eleven and twelve to be created for web:
»eleven2m4yo
»twelve2m4yo

Backup (daily): Logic /HD-GUF and FTP upload

January 30, 2015

Directions generated for medium size photos:
»dragon2m4yo
ξ DRAGON: nature, autumn

»zero2m4yo
ξ ZERO: service, vehicles

»one2m4yo
ξ ONE (x+,y+,z+) (+catch,+scene,+timing)
ξ (+got it,+wilderness,+timed it)
ξ nailed it all!

»two2m4yo
ξ TWO (x+,y-,z-) (+catch,-scene,-timing)
ξ (+got it,-forestry,-timing not ideal)
ξ got birds/rabit in spite of miserable scenes and bad timing!

»three2m4yo
ξ THREE(x+,y+,z-) (+catch,+scene,-timing
ξ (+got it,+wilderness,-timing not ideal)
ξ got birds/rabit - even with bad timing - and enjoyed wilderness!

»four2m4yo
ξ FOUR (x+,y-,z+) (+catch,-scene,+timing)
ξ (+got it,-forestry,+timed it)
ξ got birds/rabit timed although harvested forest!

»five2m4yo
ξ FIVE (x-,y+,z+) (-catch,+scene,+timing)
ξ (-missed it,+wilderness,!+timed it)
ξ no catch in wilderness with ok timing!

»six2m4yo
ξ SIX (x-,y+,z-) (-catch,+scene,-timing)
ξ (-missed it,+wilderness,!-timing not ideal)
ξ no catch in wilderness and timing not ok!

»seven2m4yo
ξ SEVEN(x-,y-,z+) (-catch,-scene,+timing)
ξ (-missed it,-forestry,+timed it)
ξ no catch and bad forestry, only timing ok!

»eight2m4yo
ξ EIGHT(x-,y-,z-) (-catch,-scene,-timing)
ξ (-missed it,-forestry,-timing not ideal)
ξ failed it all!

Medium size images for system test:
'master2analyse4search': 'J://temp//yophotos//test2master//', # [ACK] Sun <-- copied from zero ... eight once they were ready
'dragon2analyse4search': 'F://temp//yophotos//test2dragon//', # [ACK] Saturn <-- nature, autumn
'zero2analyse4search': 'D://temp//yophotos//test2zero//', # [ACK] Eris <-- service, vehicles, guns, ammo, cooking
'one2analyse4search': 'G://temp//yophotos//test2one//', # [ACK] Titan <-- ONE (x+,y+,z+) (+catch,+scene,+timing)<=> 1(+got it,+wilderness,+timed it) <=> nailed it all!
'two2analyse4search': 'H://temp//yophotos//test2two//', # [ACK] Enceladus<-- TWO (x+,y-,z-) (+catch,-scene,-timing)<=> 2(+got it,-forestry,-timing not ideal) <=> got birds/rabit in spite of miserable scenes and bad timing!
'three2analyse4search': 'I://temp//yophotos//test2three//', # [ACK] Phoebe <-- THREE(x+,y+,z-) (+catch,+scene,-timing)<=> 3(+got it,+wilderness,-timing not ideal) <=> got birds/rabit - even with bad timing - and enjoyed wilderness!
'four2analyse4search': 'K://temp//yophotos//test2four//', # [ACK] Theia <-- FOUR (x+,y-,z+) (+catch,-scene,+timing)<=> 4(+got it,-forestry,+timed it) <=> got birds/rabit timed although harvested forest!
'five2analyse4search': 'L://temp//yophotos//test2five//', # [ACK] Haumea <-- FIVE (x-,y+,z+) (-catch,+scene,+timing)<=> 5(-missed it,+wilderness,!+timed it) <=> no catch in wilderness with ok timing!
'six2analyse4search': 'M://temp//yophotos//test2six//', # [ACK] Logic <-- SIX (x-,y+,z-) (-catch,+scene,-timing)<=> 6(-missed it,+wilderness,!-timing not ideal)<=> no catch in wilderness and timing not ok!
'seven2analyse4search': 'N://temp//yophotos//test2seven//', # [ACK] Venus <-- SEVEN(x-,y-,z+) (-catch,-scene,+timing)<=> 7(-missed it,-forestry,+timed it) <=> no catch and bad forestry, only timing ok!
'eight2analyse4search': 'O://temp//yophotos//test2eight//', # [ACK] Jupiter <-- EIGHT(x-,y-,z-) (-catch,-scene,-timing)<=> 8(-missed it,-forestry,-timing not ideal) <=> failed it all!
ξ »version4xi
ξ 'base2shoot4dragon': 'https://www.yourdragonxi.org/web/temp/images/medium/',
ξ ...
ξ 'base2shoot4eight': 'https://www.yourdragonxi.org/web/temp/images/medium/',

Integrated:
»index2walk4yo

Modules in system test:
ξ »analyse2photo4search
ξ »version4xi
ξ »shoot2dragon4search
ξ »shoot2zero4search
...
ξ »shoot2eight4search
ξ »gun2eight4search
...
ξ »gun2zero4search
ξ »gun2dragon4search

Modules having produced code for system test:
ξ »dragonize2studio4xi
ξ »shoot2dragon4search
ξ »generate2shoot4search
ξ »generate2gun4search

Trace in system test:
ξ »analyse2photo4search.txt
ξ »ace-analyse2photo.xml
ξ »reason-analyse2photo.xml
ξ »sense-analyse2photo.xml

Backup (monthly): Haumea/HD-GUF and FTP upload

January 29, 2015

Directions generated for large:
»dragon2l4yo
ξ DRAGON: nature, autumn

»zero2l4yo
ξ ZERO: service, vehicles

»one2l4yo
ξ ONE (x+,y+,z+) (+catch,+scene,+timing)
ξ (+got it,+wilderness,+timed it)
ξ nailed it all!

»two2l4yo
ξ TWO (x+,y-,z-) (+catch,-scene,-timing)
ξ (+got it,-forestry,-timing not ideal)
ξ got birds/rabit in spite of miserable scenes and bad timing!

»three2l4yo
ξ THREE(x+,y+,z-) (+catch,+scene,-timing
ξ (+got it,+wilderness,-timing not ideal)
ξ got birds/rabit - even with bad timing - and enjoyed wilderness!

»four2l4yo
ξ FOUR (x+,y-,z+) (+catch,-scene,+timing)
ξ (+got it,-forestry,+timed it)
ξ got birds/rabit timed although harvested forest!

»five2l4yo
ξ FIVE (x-,y+,z+) (-catch,+scene,+timing)
ξ (-missed it,+wilderness,!+timed it)
ξ no catch in wilderness with ok timing!

»six2l4yo
ξ SIX (x-,y+,z-) (-catch,+scene,-timing)
ξ (-missed it,+wilderness,!-timing not ideal)
ξ no catch in wilderness and timing not ok!

»seven2l4yo
ξ SEVEN(x-,y-,z+) (-catch,-scene,+timing)
ξ (-missed it,-forestry,+timed it)
ξ no catch and bad forestry, only timing ok!

»eight2l4yo
ξ EIGHT(x-,y-,z-) (-catch,-scene,-timing)
ξ (-missed it,-forestry,-timing not ideal)
ξ failed it all!

[ACK] large images for system test:
'master2analyse4search': 'J://temp//yophotos//test2master//', # [ACK] Sun <-- copied from zero ... eight once they were ready
'dragon2analyse4search': 'F://temp//yophotos//test2dragon//', # [ACK] Saturn <-- nature, autumn
'zero2analyse4search': 'D://temp//yophotos//test2zero//', # [ACK] Eris <-- service, vehicles
'one2analyse4search': 'G://temp//yophotos//test2one//', # [ACK] Titan <-- ONE (x+,y+,z+) (+catch,+scene,+timing)<=> 1(+got it,+wilderness,+timed it) <=> nailed it all!
'two2analyse4search': 'H://temp//yophotos//test2two//', # [ACK] Enceladus<-- TWO (x+,y-,z-) (+catch,-scene,-timing)<=> 2(+got it,-forestry,-timing not ideal) <=> got birds/rabit in spite of miserable scenes and bad timing!
'three2analyse4search': 'I://temp//yophotos//test2three//', # [ACK] Phoebe <-- THREE(x+,y+,z-) (+catch,+scene,-timing)<=> 3(+got it,+wilderness,-timing not ideal) <=> got birds/rabit - even with bad timing - and enjoyed wilderness!
'four2analyse4search': 'K://temp//yophotos//test2four//', # [ACK] Theia <-- FOUR (x+,y-,z+) (+catch,-scene,+timing)<=> 4(+got it,-forestry,+timed it) <=> got birds/rabit timed although harvested forest!
'five2analyse4search': 'L://temp//yophotos//test2five//', # [ACK] Haumea <-- FIVE (x-,y+,z+) (-catch,+scene,+timing)<=> 5(-missed it,+wilderness,!+timed it) <=> no catch in wilderness with ok timing!
'six2analyse4search': 'M://temp//yophotos//test2six//', # [ACK] Logic <-- SIX (x-,y+,z-) (-catch,+scene,-timing)<=> 6(-missed it,+wilderness,!-timing not ideal)<=> no catch in wilderness and timing not ok!
'seven2analyse4search': 'N://temp//yophotos//test2seven//', # [ACK] Venus <-- SEVEN(x-,y-,z+) (-catch,-scene,+timing)<=> 7(-missed it,-forestry,+timed it) <=> no catch and bad forestry, only timing ok!
'eight2analyse4search': 'O://temp//yophotos//test2eight//', # [ACK] Jupiter <-- EIGHT(x-,y-,z-) (-catch,-scene,-timing)<=> 8(-missed it,-forestry,-timing not ideal) <=> failed it all!
ξ »version4xi
ξ 'base2shoot4dragon': 'https://www.yourdragonxi.org/web/temp/images/large/',
ξ ...
ξ 'base2shoot4eight': 'https://www.yourdragonxi.org/web/temp/images/large/',

January 27, 2015

Modules in system test:
ξ »analyse2photo4search
ξ »version4xi
ξ »shoot2dragon4search
ξ »shoot2zero4search
...
ξ »shoot2eight4search
ξ »gun2eight4search
...
ξ »gun2zero4search
ξ »gun2dragon4search

Modules producing code for system test:
ξ »dragonize2studio4xi
ξ »shoot2dragon4search
ξ »generate2shoot4search
ξ »generate2gun4search

[ACK] Content created for system test:
master # [ACK] Sun <-- copied from zero ... eight once they were ready
test2dragon # [ACK] Saturn <-- nature, autumn
test2zero # [ACK] Eris <-- service, vehicles, isanpaiva
test2one # [ACK] Titan <-- ONE (x+,y+,z+) (+catch,+scene,+timing)<=> 1(+got it,+wilderness,+timed it) <=> nailed it all!
test2two # [ACK] Enceladus<-- TWO (x+,y-,z-) (+catch,-scene,-timing)<=> 2(+got it,-forestry,-timing not ideal) <=> got birds/rabit in spite of miserable scenes and bad timing!
test2three # [ACK] Phoebe <-- THREE(x+,y+,z-) (+catch,+scene,-timing)<=> 3(+got it,+wilderness,-timing not ideal) <=> got birds/rabit - even with bad timing - and enjoyed wilderness!
test2four # [ACK] Theia <-- FOUR (x+,y-,z+) (+catch,-scene,+timing)<=> 4(+got it,-forestry,+timed it) <=> got birds/rabit timed although harvested forest!
test2five # [ACK] Haumea <-- FIVE (x-,y+,z+) (-catch,+scene,+timing)<=> 5(-missed it,+wilderness,!+timed it) <=> no catch in wilderness with ok timing!
test2six # [ACK] Logic <-- SIX (x-,y+,z-) (-catch,+scene,-timing)<=> 6(-missed it,+wilderness,!-timing not ideal)<=> no catch in wilderness and timing not ok!
test2seven # [ACK] Venus <-- SEVEN(x-,y-,z+) (-catch,-scene,+timing)<=> 7(-missed it,-forestry,+timed it) <=> no catch and bad forestry, only timing ok!
test2eight # [ACK] Jupiter <-- EIGHT(x-,y-,z-) (-catch,-scene,-timing)<=> 8(-missed it,-forestry,-timing not ideal) <=> failed it all!

ξ designed all directions containing cam size hunting images to see whether 3D view about hunting would offer anything new
ξ X = catch (+got it! /-missed it!)
ξ Y = scene (+wilderness! /-forestry!)
ξ Z = timing (+timed it! /-timing to improve!)
ξ »verb4xi
ξ used as a model for 3D directions
»OneDrive
ξ used as a visual help to select content to directions
J:\temp\yophotos\test2master\h\hunting\pudasjarvikanalinnustus <-- *** bug found; no date!
»all2c4yo
ξ updated - bug was due to days of Minolta Dynax 7000i which did not register dates being a film camera!

Directions generated:
[ACK] »"file:///F:/temp/yophotos/test2dragon/index2xxxxxxxx4yo.html" target="_blank">test2dragon
[ACK] »"file:///E:/DRAGONXI/PC4Xi/YoDragonXiOrg/WebSite/stock4xi/dragon2c4yo.html" target="_blank">dragon2c4yo
[ACK] »dragon2c4yo - web
ξ DRAGON: nature, autumn

[ACK] »"file:///D:/temp/yophotos/test2zero/index2xxxxxxxx4yo.html" target="_blank">test2zero
[ACK] »"file:///E:/DRAGONXI/PC4Xi/YoDragonXiOrg/WebSite/stock4xi/zero2c4yo.html" target="_blank">zero2c4yo
[ACK] »zero2c4yo - web
ξ ZERO: service, vehicles, isanpaiva

[ACK] »"file:///G:/temp/yophotos/test2one/index2xxxxxxxx4yo.html" target="_blank">test2one
[ACK] »"file:///E:/DRAGONXI/PC4Xi/YoDragonXiOrg/WebSite/stock4xi/one2c4yo.html" target="_blank">one2c4yo
[ACK] »one2c4yo - web
ξ ONE (x+,y+,z+) (+catch,+scene,+timing)<=> 1(+got it,+wilderness,+timed it) <=> nailed it all!

[ACK] »"file:///H:/temp/yophotos/test2two/index2xxxxxxxx4yo.html" target="_blank">test2two
[ACK] »"file:///E:/DRAGONXI/PC4Xi/YoDragonXiOrg/WebSite/stock4xi/two2c4yo.html" target="_blank">two2c4yo
[ACK] »two2c4yo - web
ξ TWO (x+,y-,z-) (+catch,-scene,-timing)<=> 2(+got it,-forestry,-timing not ideal) <=> got birds/rabit in spite of miserable scenes and bad timing!

[ACK] »"file:///I:/temp/yophotos/test2three/index2xxxxxxxx4yo.html" target="_blank">test2three
[ACK] »"file:///E:/DRAGONXI/PC4Xi/YoDragonXiOrg/WebSite/stock4xi/three2c4yo.html" target="_blank">three2c4yo
[ACK] »three2c4yo - web
ξ THREE(x+,y+,z-) (+catch,+scene,-timing)<=> 3(+got it,+wilderness,-timing not ideal) <=> got birds/rabit - even with bad timing - and enjoyed wilderness!

[ACK] »"file:///K:/temp/yophotos/test2four/index2xxxxxxxx4yo.html" target="_blank">test2four
[ACK] »"file:///E:/DRAGONXI/PC4Xi/YoDragonXiOrg/WebSite/stock4xi/four2c4yo.html" target="_blank">four2c4yo
[ACK] »four2c4yo - web
ξ FOUR (x+,y-,z+) (+catch,-scene,+timing)<=> 4(+got it,-forestry,+timed it) <=> got birds/rabit timed although harvested forest!

[ACK] »"file:///L:/temp/yophotos/test2five/index2xxxxxxxx4yo.html" target="_blank">test2five
[ACK] »"file:///E:/DRAGONXI/PC4Xi/YoDragonXiOrg/WebSite/stock4xi/five2c4yo.html" target="_blank">five2c4yo
[ACK] »five2c4yo - web
ξ FIVE (x-,y+,z+) (-catch,+scene,+timing)<=> 5(-missed it,+wilderness,!+timed it) <=> no catch in wilderness with ok timing!

[ACK] »"file:///M:/temp/yophotos/test2six/index2xxxxxxxx4yo.html" target="_blank">test2six
[ACK] »"file:///E:/DRAGONXI/PC4Xi/YoDragonXiOrg/WebSite/stock4xi/six2c4yo.html" target="_blank">six2c4yo
[ACK] »six2c4yo - web
ξ SIX (x-,y+,z-) (-catch,+scene,-timing)<=> 6(-missed it,+wilderness,!-timing not ideal)<=> no catch in wilderness and timing not ok!

[ACK] »"file:///N:/temp/yophotos/test2seven/index2xxxxxxxx4yo.html" target="_blank">test2seven
[ACK] »"file:///E:/DRAGONXI/PC4Xi/YoDragonXiOrg/WebSite/stock4xi/seven2c4yo.html" target="_blank">seven2c4yo
[ACK] »seven2c4yo - web
ξ SEVEN(x-,y-,z+) (-catch,-scene,+timing)<=> 7(-missed it,-forestry,+timed it) <=> no catch and bad forestry, only timing ok!

[ACK] »"file:///O:/temp/yophotos/test2eight/index2xxxxxxxx4yo.html" target="_blank">test2eight
[ACK] »"file:///E:/DRAGONXI/PC4Xi/YoDragonXiOrg/WebSite/stock4xi/eight2c4yo.html" target="_blank">eight2c4yo
[ACK] »eight2c4yo - web
ξ EIGHT(x-,y-,z-) (-catch,-scene,-timing)<=> 8(-missed it,-forestry,-timing not ideal) <=> failed it all!

Trace in system test:
ξ »analyse2photo4search.txt
ξ »ace-analyse2photo.xml
ξ »reason-analyse2photo.xml
ξ »sense-analyse2photo.xml

Backup: Theia/HD-GUF and FTP upload

January 26, 2015
ξ »analyse2photo4search
ξ »analyse2photo4search.txt
ξ LevelTwoKB4Xi statistics printed about those without date and the ones with date
ξ dog30mars2013 <-- dog30march2013 (syntax mistake revealed)
ξ vehicles, visits, usa, hiking, hunting, fashion, fishing, flowers, cooking, birds <-- LevelTwoKB4Xi
ξ LevelThreeKB4Xi <-- huntinghunting18september2006 <-- hunting18september2006
ξ alavuokki2october2010 <-- challenge: subfolder name does not embed domain
ξ flower18september2014 <-- challenge: main folder is flowers whereas subfolder names start with flower!
ξ honkasaari20july2014 <-- challenge: subfolder name does not embed domain
ξ DomainKB4Xi[ usa ] [ kuusamo17june2014 ] = {} <-- challenge here: domain name is a part of a longer folder name!
ξ DomainKB4Xi[ hunting ] [ birdhunting10september2012 ] = {} <-- OK
ξ DomainKB4Xi[ hunting ] [ snowhunting2006 ] = {} <-- OK
ξ DomainKB4Xi[ flowers ] [ flowers20august2014 ] = {} <-- OK
ξ DomainKB4Xi[ fishing ] [ fishing2pesio4pike14july2000 ] = {} <-- OK
ξ due to non standard naming conventions folder and subfolder naming can not be used for domain statistics in level 3
ξ only level two folders without dates might be useful for domain statistics
ξ it is wiser and more flexible to let content depict directions zero, one ... eight, where
ξ zero = images directly under folders like in DriveOne
ξ one = the ones suitable for (+,+,+)
ξ
ξ eight = the ones suitable for (-,-,-)
ξ »All2Cam
ξ upgraded dog30march2013 and hunting18september2006 aftef ftp upgrade

Backup (full): Haumea/HD-GUF and FTP upload

January 23, 2015
ξ »analyse2photo4search
ξ upgraded to process direction zero and to use master folder to its own statistics
ξ F:\OneDrive\SmallSmart\ronnie\Images\cam\a <-- from images directly from alphabetic folders only - as in OneDrive
ξ D:\temp\yophotos\test2zero\a <-- to images directly under alphabetic folders
ξ »version4xi
ξ »"file:///D:/temp/yophotos/test2zero/index2xxxxxxxx4yo.html" target="_blank">HTML built (local)
ξ »Image in Web
ξ »"file:///E:/DRAGONXI/PC4Xi/YoDragonXiOrg/WebSite/stock4xi/top2c4yo.html" target="_blank">TopCam (local)
ξ »Image in Web
ξ »TopCam <-- menu in web!
ξ »Walk4yo <-- integrated!
ξ built hyperlinks to images presenting each alphabetic folder i.e. kind of Top images using direction zero
ξ master folder was used to present all images
ξ »parse2studio4xi
ξ parsed totally 36 tags in : 56 modules <-- verified the syntax in all modules - automatically generated included

Modules in system test:
ξ »analyse2photo4search
ξ »version4xi
ξ »dragonize2studio4xi
ξ »gun2zero4search
ξ »shoot2zero4search
ξ »generate2shoot4search
ξ »generate2gun4search
ξ »shoot2one4search
ξ »shoot2two4search
ξ »shoot2three4search
ξ »shoot2four4search
ξ »shoot2five4search
ξ »shoot2six4search
ξ »shoot2seven4search
ξ »shoot2eight4search
ξ »gun2eight4search
ξ »gun2seven4search
ξ »gun2six4search
ξ »gun2five4search
ξ »gun2four4search
ξ »gun2three4search
ξ »gun2two4search
ξ »gun2one4search
ξ »shoot2dragon4search
ξ »version2fb4xi
ξ »gun2dragon4search
ξ »version2riika4xi
ξ »add2index4xi
ξ »parse2studio4xi

New web content from system test:
ξ »TopCam

Trace in system test:
ξ »analyse2photo4search.txt
ξ »ace-analyse2photo.xml
ξ »reason-analyse2photo.xml
ξ »sense-analyse2photo.xml

Backup: Phoebe/HD-GUF (whole Python\3.3) and FTP upload

January 22, 2015
ξ »analyse2photo4search
ξ embedded trace as documentation
ξ corrected (Step 33A/33) path to zero2analyse4search <-- J://temp//yophotos//cam//
ξ queue and pipes discovered to have been created for zero but process not activated!
ξ »shoot2eight4search
ξ failed to calculate statistics because the maximum size for images was wrong in some directions
ξ »version4xi
ξ increased maximum file size to 33000000 for all directions

Backup: Enceladus/HD-GUF and FTP upload

January 21, 2015

Explored the idea to add command and control messages and data between main program and target functions for verifying results
ξ background: IDC and similar communication protocols are looking for new ideas to process videos and images produced by UAS systems
ξ conclusion: images used in these tests could simulate images gathered by UAVs, basestations and sensors!
ξ capability to concurrently process up to eight image sets and produce 3D sphere information would offer a competitive edge!
ξ however, by waiting each activated process to finish and to communicate its results via pipe and queue - even summary -
ξ may increase risks to end up waiting forever in the main program - instead letting them independently do their best!
ξ one option for each activated task might be to send ack message and put statistics to queue
ξ letting main program to decide whether to receive those messages and get the corresponding data from queues

System test:
ξ »analyse2photo4search
ξ coded and tested directions one ... eight
ξ »dragonize2studio4xi
ξ upgraded to be easier to use
ξ »shoot2dragon4search
ξ »gun2dragon4search
ξ models (input) for automatic software generation by software
ξ »generate2shoot4search
ξ »generate2gun4search
ξ inherited (specialized, tuned) from »dragonize2studio4xi
ξ »version4xi
ξ upgraded for one ... eight
ξ »parsestudio4xi
ξ parsed totally 36 tags in 55
ξ »macro4xi
ξ regenerated macros

Generated programs:
ξ »shoot2zero4search
ξ »shoot2one4search
ξ »shoot2two4search
ξ »shoot2three4search
ξ »shoot2four4search
ξ »shoot2five4search
ξ »shoot2six4search
ξ »shoot2seven4search
ξ »shoot2eight4search
ξ »gun2zero4search
ξ »gun2one4search
ξ »gun2two4search
ξ »gun2three4search
ξ »gun2four4search
ξ »gun2five4search
ξ »gun2six4search
ξ »gun2seven4search
ξ »gun2eight4search

Generated files(local):
»"file:///F:/temp/yophotos/test2dragon/index2xxxxxxxx4yo.html" target="_blank">test2dragon
»"file:///G:/temp/yophotos/test2one/index2xxxxxxxx4yo.html" target="_blank">test2one
»"file:///H:/temp/yophotos/test2two/index2xxxxxxxx4yo.html" target="_blank">test2two
»"file:///I:/temp/yophotos/test2three/index2xxxxxxxx4yo.html" target="_blank">test2three
»"file:///K:/temp/yophotos/test2four/index2xxxxxxxx4yo.html" target="_blank">test2four
»"file:///L:/temp/yophotos/test2five/index2xxxxxxxx4yo.html" target="_blank">test2five
»"file:///M:/temp/yophotos/test2six/index2xxxxxxxx4yo.html" target="_blank">test2six
»"file:///N:/temp/yophotos/test2seven/index2xxxxxxxx4yo.html" target="_blank">test2seven
»"file:///O:/temp/yophotos/test2eight/index2xxxxxxxx4yo.html" target="_blank">test2eight

Backup (whole): Titan/HD-GUF and FTP upload

January 19, 2015

ξ »"file:///F:/temp/yophotos/test2dragon/index2xxxxxxxx4yo.html" target="_blank">test2dragon (local)
ξ »version4xi
ξ redesigned test data allocation as well as naming of test folders and populated test data into each
ξ 'zero2analyse4search': 'J://temp//yophotos//cam//', # Sun <-- analyse2photo4search.py as main only
ξ 'dragon2analyse4search': 'F://temp//yophotos//test2dragon//', # Saturn <-- gun2dragon4search.py / shoot2dragon4search.py
ξ ...
ξ 'eight2analyse4search': 'O://temp//yophotos//test2eight//', # Jupiter <-- gun2eight4search.py / shoot2eight4search.py
ξ 'nine2analyse4search': 'P://temp//yophotos//test2nine//', # Kelvin <-- first extra
ξ ...
ξ 'twelve2analyse4search': 'R://temp//yophotos//test2twelve//', # HD-GDUR <-- last extra
ξ »analyse2photo4search
ξ »shoot2dragon4search
ξ »gun2dragon4search
ξ »analyse2photo4search.txt
ξ »ace-analyse2photo.xml
ξ »reason-analyse2photo.xml
ξ »sense-analyse2photo.xml
ξ dragon (module to be used to automatically generate other modules tested!

Backup: Saturn/HD-GUF (both STUDI4XI and DRAGONXI and WEB/xml) and FTP upload <-- the milestone to have dragon module tested achieved!

ξ »shoot2zero4search.py
ξ edited manually using shoot2dragon4search.py generated from shoot2one4search.py
ξ »shoot2dragon4search
ξ regenerated using shoot2zero4search.py as the model by »dragonize2studio4xi
ξ »gun2dragon4search
ξ used as model saving as gun2zero4search.py
ξ »gun2zero4search
ξ generated by »dragonize2studio4xi
ξ »shoot2one4search.py
ξ »gun2one4search.py
ξ as before because this a model
ξ »analyse2photo4search
ξ upgraded to handle dragon first - the goal being to get dragon modules to work for automatic software generation

Backup: Enceladus/HD-GUF /FTP upload --> FTP download --> tests in other workstation
ξ »version2riika4xi
ξ L:\temp\yophotos\test2dragon ... L:\temp\yophotos\test2eight <-- subsets of M:\temp\yophotos\cam\
ξ proved advantages having small and context based subsets such as L:\temp\yophotos\test2dragon\d\dragonfly29july2012 for testing

Backup: Innovation and Ceres / FTP upload

January 18, 2015
ξ »analyse2photo4search
ξ »shoot2one4search.py
ξ »gun2one4search.py
ξ »version4xi
ξ »dragonize2scope4xi <-- model
ξ added keys 'dragon2analyse4search', max2short4dragon' and 'maxsize2file4dragon'
ξ »dragonize2studio4xi <-- new
ξ »generate2commandqueue4scope <-- model
ξ »generate2shoot4search <-- new
ξ »generate2gun4search <-- new
ξ E:\temp\dragonize\in\gun2one4search.py <-- input
ξ E:\temp\dragonize\out\gun2dragon4search.py <-- output
ξ »gun2dragon4search
ξ »shoot2dragon4search
ξ generated and got compiled OK

Backup: Titan, HD-GUF (FastBlack), FTP uploaded / King, Ceres (RiikaPC)

January 15, 2015
ξ explored the idea to manage n instead of eight(8) processes and let gun modules to create, start and run processes
ξ the goal would be a scalable solution suitable to various environments

Backup: Saturn, HD-GUF, not server due to FTP upload

January 14, 2015

Images:
ξ /home/icefellow/webapps/yodragonxiorg/stock4xi/images <-- deleted thereby releasing free space to 65GB (only 35% used of 100GB) in WebFaction server
ξ J:\PHOTOS\yodragonxiorg\web\temp\images\jpg\server\cam <-- copied from zip downloaded from OneDrive and unzipped images
ξ created original digital camera image folder updating folder and image dates by comparing to those in OneDrive when appropriate
ξ ftp-uploaded to /home/icefellow/webapps/yodragonxiorg/web/temp/images with index.html generated by »add2index4xi
ξ with ftp one can let system to handle the upload and simultaneously do something else compared to having sit and click with each folder as is the case with OneDrive!

Scope4Xi exploration for software generation with software:

OpenCL API interface module capable to master buffer management of {APU ... GPU ... ZPU} as one virtual processing unit!
ξ »buffer4xi <-- OpenCL interface module for Buffer Management
ξ from apu2buffer4xi import APU2Buffer4Xi ... from zpu2buffer4xi import ZPU2Buffer4Xi <-- due to version4xi capable to import from subfolders a ... z
ξ from apu2buffer4xi import create2buffer4apu ... from zpu2buffer4xi import create2buffer4zpu
ξ buffer4xi['APU'] = create2buffer4apu() ... buffer4xi['ZPU'] = create2buffer4zpu() <-- if ack2all is True
ξ buffer4xi['APU'] = create2buffer4apu(task4create2buffer['APU']) <-- else i.e. only for APU
ξ buffer4xi ['IPU'] = set2buffer4ipu(task4set2buffer['IPU']) <-- capable to operate with any processing unit once data to all processing units is available!
ξ cc2xi['APU'] = get2bufferinfo4apu() <-- capabable to get data from any processing unit!
ξ Buffer4Xi <-- offers methods for Buffer, compatible with OpenCL specifications

Module testing buffer management of {APU ... GPU ... ZPU} processing units as one virtual device!
ξ »buffer4xi5test <-- tests buffer management for {APU ... ZPU}
ξ cq2xi = create2buffer4xi() / cqinfo2xi = get2bufferinfo4xi() <-- {'VPU': {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0 ... 'CPU': {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0 ...
ξ device2xi = init2device4xi() <-- initializes all devices APU ... ZPU
ξ task4create2buffer ['APU'] ['CONTEXT'] = context2xi ['APU'] ... task4create2buffer ['ZPU'] ['CONTEXT'] = context2xi ['ZPU'] <-- context defined to all devices
ξ arena2apu = Arena4Xi(length2apu) ... arena2zpu = Arena4Xi(length2zpu) <-- working arena to all processing units
ξ response4create2buffer = create2buffer4xi(task4create2buffer) <-- creates buffer to all processing units

Dragon modules (edited manually) to automatiocally generate software to processing units {BPU ... GPU ... ZPU}
ξ »dragon2buffer4xi <-- used to create buffer management to virtual dragon processing unit
ξ »dragon2commandqueue4xi <-- used to command queues to virtual dragon processing unit
ξ »dragon2commandqueue4xi5test <-- tests command queues with virtual dragon processing unit

Software generated modules:
ξ »gpu2buffer4xi <-- manages buffer management with GPU
ξ »zpu2commandqueue4xi <-- handles command queues with ZPU
ξ »zpu2commandqueue4xi5test <-- tests command queues with ZPU

Studio4Xi exploration for software generation with software:
ξ »dragonize2scope4xi <-- dragonize2studio4xi.py to be created for Studio4Xi!
ξ L://temp//py//apu2image4xi.py <-- reads and L://temp//py//dragon2image4xi.py <-- writes
ξ programs for APU processing unit are first created and tested, then used to generate for {BPU...ZPU}, the one for APU is kept for upgrades and tests
ξ looks for device specific string such as apu, APU <-- master ones because you first create modules for APU processing unit (and keep them)!
ξ is smart in processing input lines: is device specific string is found, it checks whether it could be for other modules

After dragon module has been created by Studio4Xi:
ξ »generate2commandqueue4scope <-- generate2shoot4search.py and generate2gun4search.py to be created!
ξ generates commandqueue programs to commandqueues from virtual dragon commandqueue
ξ search patterns: dragon / DRAGON <-- seldom used but are not unique strings (for example program macros have them)!
ξ kb2tailor ['b'] ['module'] = 'bpu2commandqueue4xi5test.py' / kb2tailor ['b'] ['dragon'] = 'bpu' / kb2tailor ['b'] ['DRAGON'] = 'BPU' / kb2tailor ['b'] ['line'] = 'default: line not generated from input'
ξ kb2keep[1] = "#ξ L://job//041721//studio4xi//cc//generate//in//lib//dragon//dragon2commandqueue4xi.py <-- reads
ξ L://job//041721//studio4xi//cc//generate//out//lib//z//zpu2commandqueue4xi.py <-- writes
ξ processes ram table after having read input file <-- speeds processing!
ξ # --> #

Multiprocessing4Xi exploration for software generation with software:
ξ »verb4xi
ξ DirectionKB4Xi <-- directions 0, 1 ... 8 to be selected for testing
ξ charge2one4xi ... charge2eight4xi / cluster2a4xi ... cluster2_4xi
ξ ONE (X + ,Y + ,Z + )/TWO(X + ,Y - ,Z - )/THREE(X + ,Y + ,Z - )/FOUR (X + ,Y - ,Z + )
ξ FIVE(X - ,Y + ,Z + )/SIX(X - ,Y + ,Z - )/SEVEN(X - ,Y - ,Z + )/EIGHT(X - ,Y - ,Z - )
ξ from verb2a4xi import Verb2a4Xi ... from verb2_4xi import Verb2_4Xi
ξ ack2one4process, ack2one4start, ack2one4run ... ack2eight4process, ack2eight4start, ack2eight4run
ξ ClusterColorStatistics4Xi, ClusterKB4Xi, ClusterColor4Xi
ξ fired (x,y,z)-coordinate dictionaries received from queue data produced by fire-function threads 1...33 of processesses 1 ...8
ξ pipe2zero_consumer_channel/pipe2zero_publisher_channel ... pipe2eight_consumer_channel/pipe2eight_publisher_channel
ξ p2one ... p2eight <-- Processes - one for each direction 1 ... 8
ξ queue2zero ... queue2eight <-- Queues - queue zero for main program - queue 1...8 for process 1...8
ξ SuperClusterColor4Xi <-- eight super clusters - one for each telescope view
ξ SymbolColor4Xi - base symbols for verbs - final symbol by combining these as required
ξ SuperClusterColorStatistics4Xi <-- 0 ... 8 / VerbKB4Xi <-- a ... z
ξ analyze_verb4xi function <-- analyzes verb knowledgebase
ξ color_tenses4xi() <-- colors verb tenses / creates process communication
ξ command and control messages put and get manoeuvres
ξ creates 8 processes ...(p2eight = Process4Xi(target=charge2eight4xi, args=(queue2eight, pipe2eight_consumer_channel, pipe2eight_publisher_channel))
ξ starts and runs processes - for directions one to eight - if required i.e. if DirectionKB4Xi[x] is True, where x=1...8
ξ get answers from queues to control messages - from queues of each eight processes (roger2one ... roger2eight)
ξ receives via pipes answers to control message - from each of eight processes (roger2one ... roger2eight)
ξ receives info about succesfull dictionary put via pipes from each process/direction - master ones only <-- note: all data NOT via gueue!
ξ »charge2eight4xi
ξ dummy2eight = DummyProcess4Xi(target=fire2eight4xi, args =(queue2work4eight,channel2consume4eight, channel2publish4eight))
ξ ...
ξ dummy3300eight = DummyProcess4Xi(target=fire3300eight4xi, args =(queue2work4eight,channel2consume4eight, channel2publish4eight))
ξ »fire2eight4xi
ξ fire2eight4xi(queue2eight, consumer_channel2eight, publisher_channel2eight) <-- usage
ξ »fire3300eight4xi
ξ »shoot2eight4xi
ξ »shoot4xi
ξ defines four (x,y,z) coordinated dictionaries for all levels, up to shot2eight33004xi

Backup: Saturn, HD-GUF and Server

January 13, 2015
ξ »analyse2photo4search
ξ to be mastered command and control after having activated missions
ξ »shoot2one4search.py
ξ to be added writing statistics into HTML file
ξ »gun2one4search.py
ξ to be added command and control after having activated DummyProcess4Xi
ξ »version4xi
ξ to be added dragon program for software generation

ξ file:///J:/PHOTOS/yodragonxiorg/web/temp/images/jpg/server/raw/a/index2a4yo.html <-- raw images
ξ https://www.yourdragonxi.org/web/temp/images/raw/a/autumnscolors/autumnscolors%20(1).JPG <-- not found, had been moved to /stock4xi !
ξ J:\PHOTOS\yodragonxiorg\web\temp\images\jpg\server\raw <-- /stock4xi in server!
ξ J:\PHOTOS\yodragonxiorg\web\temp\images\jpg\server <-- hyperlinks built by »build2hyperlink4content.py
ξ to be solved: new medium and large are in /web/temp/images and older ones in /stock4xi/web/temp <-- medium and large extra here!
ξ to be decided how images are being used; just as test images instead of trying to keep raw images to be sold!
ξ in photos are kept in war then links could be built with new programs!
ξ to be considered to redesign/reallocate/rearrage raw sized images based on OneDrive - as was done for large and medium images!
ξ anyhow you must have only the top images in digicam size to save space in www.yourdragonxi.org site!
ξ see what you have locally and in server and then delete extra in server (medium and large are in two places!

Compared in OneDrive to Fastblack (images for OneDrive folders omitted)
[ACK] J:\PHOTOS\yodragonxiorg\web\temp\images\jpg\server\small
[NACK]

Backup (fresh i.e. first deleted old backup):
[ACK] J:\PHOTOS\yodragonxiorg\web\temp\images\jpg\server\medium <-- Sun
ξ[ACK] N:\Backup\PHOTOS\yodragonxiorg\web\temp\images\jpg\server\medium <-- Venus
ξ[ACK] U:\PHOTOS\yodragonxiorg\web\temp\images\jpg\server\medium <-- USB FastBlack
ξ[ACK] T:\PHOTOS\yodragonxiorg\web\temp\images\jpg\server\medium <-- RiikaPC USB
ξ[ACK] E:\DRAGONXI\WebFaction\Web306\FTPWeb306\home\icefellow\webapps\yodragonxiorg\web\temp\images\medium
ξ[ACK] F:\Backup\DRAGONXI\WebFaction\Web306\FTPWeb306\home\icefellow\webapps\yodragonxiorg\web\temp\image\smedium
ξ[ACK] K:\DRAGONXI\WebFaction\Web306\FTPWeb306\home\icefellow\webapps\yodragonxiorg\web\temp\images\medium
ξ[ACK] L:\Backup\VistaE\DragonXi\WebFaction\Web306\FTPWeb306\home\icefellow\webapps\yodragonxiorg\web\temp\images\medium
ξ[ACK] M:\Backup\DragonXi\WebFaction\Web306\FTPWeb306\home\icefellow\webapps\yodragonxiorg\web\temp\images\medium
ξ[ACK] N:\Backup\DRAGONXI\WebFaction\Web306\FTPWeb306\home\icefellow\webapps\yodragonxiorg\web\temp\images\medium
ξ[ACK] R:\Backup\dragonxi\WebFaction\Web306\FTPWeb306\home\icefellow\webapps\yodragonxiorg\web\temp\images\medium
ξ[ACK] T:\DRAGONXI\Webfaction\web306\ftpweb306\home\icefellow\webapps\yodragonxiorg\web\temp\images\medium
ξ[ACK] U:\DRAGONXI\WebFaction\Web306\FTPWeb306\home\icefellow\webapps\yodragonxiorg\web\temp\images\medium

[ACK] J:\PHOTOS\yodragonxiorg\web\temp\images\jpg\server\large <-- Sun
ξ[ACK] E:\DRAGONXI\WebFaction\Web306\FTPWeb306\home\icefellow\webapps\yodragonxiorg\web\temp\images\large
ξ[ACK] F:\Backup\DRAGONXI\WebFaction\Web306\FTPWeb306\home\icefellow\webapps\yodragonxiorg\web\temp\images\large
ξ[ACK] K:\DRAGONXI\WebFaction\Web306\FTPWeb306\home\icefellow\webapps\yodragonxiorg\web\temp\images\large
ξ[ACK] L:\Backup\VistaE\DragonXi\WebFaction\Web306\FTPWeb306\home\icefellow\webapps\yodragonxiorg\web\temp\images\large
ξ[ACK] M:\Backup\DragonXi\WebFaction\Web306\FTPWeb306\home\icefellow\webapps\yodragonxiorg\web\temp\images\large
ξ[ACK] N:\Backup\DRAGONXI\WebFaction\Web306\FTPWeb306\home\icefellow\webapps\yodragonxiorg\web\temp\images\large
ξ[ACK] R:\Backup\dragonxi\WebFaction\Web306\FTPWeb306\home\icefellow\webapps\yodragonxiorg\web\temp\images\large
ξ[ACK] T:\DRAGONXI\Webfaction\web306\ftpweb306\home\icefellow\webapps\yodragonxiorg\web\temp\images\large
ξ[ACK] U:\DRAGONXI\WebFaction\Web306\FTPWeb306\home\icefellow\webapps\yodragonxiorg\web\temp\images\large

Prepared new cam(raw):
[ACK] J:\PHOTOS\yodragonxiorg\web\temp\images\jpg\server\raw <-- deleted
[ACK] J:\PHOTOS\yodragonxiorg\web\temp\images\jpg\server\cam\ <-- F:\OneDrive\SmallSmart\ronnie\Images\cam (9.74 GB HD local)
ξ [ACK] deleted images presenting folders in OneDrive
ξ [ACK] modified names to have a date - used 2015 for those to be checked with OneDrive or folders for camera (Minolta Dynax 7000i images have no date)
ξ »add2index4xi
ξ »version4xi
ξ [ACK] generated index.html (worked like angel)

[NACK] J:\PHOTOS\yodragonxiorg\web\temp\images\jpg\server\large <-- Sun
ξ[NACK] N:\Backup\PHOTOS\yodragonxiorg\web\temp\images\jpg\server\large <-- Venus
ξ[NACK] U:\PHOTOS\yodragonxiorg\web\temp\images\jpg\server\large <-- USB FastBlack
ξ[NACK] T:\PHOTOS\yodragonxiorg\web\temp\images\jpg\server\large <-- RiikaPC USB

OneDrive Zip downloaded:
[NACK] F:\OneDrive\ZipDownload\sec\Images\medium
[NACK] F:\OneDrive\ZipDownload\ronnie\Images\large

OneDrive unzipped:
[NACK] F:\OneDrive\SmallSmart\sec\Images\medium\
[NACK] F:\OneDrive\SmallSmart\ronnie\Images\ipod
[NACK] F:\OneDrive\SmallSmart\ronnie\Images\large
[NACK] F:\OneDrive\SmallSmart\ronnie\Images\cam
[NACK] F:\OneDrive\SmallSmart\ronnie\Images\small

WebFaction:
[NACK] /home/icefellow/webapps/yodragonxiorg/stck/web/temp/images <-- check in control panel (next day)
[NACK] J:\PHOTOS\yodragonxiorg\web\temp\images\jpg\server\ipod
[ ACK] J:\PHOTOS\yodragonxiorg\web\temp\images\jpg\server\large <=> [NACK] == Ronnie OneDrive ? <=> [NACK] web\temp\images\ <=> [NACK] delete or keep in /stock4xi ?
[ ACK] J:\PHOTOS\yodragonxiorg\web\temp\images\jpg\server\medium <=> [ ACK] == SEC OneDrive <=> [ ACK] web\temp\images\ <=> [NACK] delete in /stock4xi
[NACK] J:\PHOTOS\yodragonxiorg\web\temp\images\jpg\server\raw
[NACK] J:\PHOTOS\yodragonxiorg\web\temp\images\jpg\server\small
[NACK] J:\PHOTOS\yodragonxiorg\web\temp\images\jpg\server\thumb

Backup: Uranus, HD-GUF and Server

January 12, 2015
ξ »analyse2photo4search
ξ »shoot2one4search.py
ξ »gun2one4search.py
ξ »version4xi
ξ J:\temp\yophotos\test <=> J:\temp\yophotos\large <-- large images used
ξ J:\PHOTOS\yodragonxiorg\web\temp\images\jpg\server\large <=> https://www.yourdragonxi.org/web/temp/images/large/
ξ created hyperlinks to different kind of large images and documented as examples
»"file:///F:/temp/yophotos/test/index2xxxxxxxx4yo.html" target="_blank">index2xxxxxxxx4yo.html <-- generated in workstation
»"file:///E:/DRAGONXI/PC4Xi/YoDragonXiOrg/WebSite/stock4xi/all2l4yo.html" target="_blank">all2l4yo <-- to be ftp uploaded from workstation after header has been edited

»Walk4yo <-- updated with links to generated image hyperlinks
»All2large <-- links to all large images in the server
»Nature2l <-- links to nature large images in the server
»Fashiom (medium)
»Hunt (medium)
»Hunt (large)
»All (medium)

Backup: Venus, HD-GUF and Server

January 11, 2015
ξ »analyse2photo4search
ξ J:\PHOTOS\yodragonxiorg\web\temp\images\jpg\server\large <=> https://www.yourdragonxi.org/web/temp/images/large/
ξ large image tests
ξ »shoot2one4search.py
ξ ack2debug4one added to debug, if necessary
ξ »gun2one4search.py
ξ »version4xi
ξ 'base2shoot4one': 'https://www.yourdragonxi.org/web/temp/images/large/',
ξ 'zero2analyse4search': 'J://temp//yophotos//large//', # Sun (original-used by analyse2photo4search.py only)
ξ J:\PHOTOS\yodragonxiorg\web\temp\images\jpg\server\medium <=> https://www.yourdragonxi.org/web/temp/images/medium/
ξ deleted individual images locallly and in server presenting folders in SkyDrive
ξ J:\temp\yophotos\test <=> J:\temp\yophotos\large <-- large images tested
ξ E:\DRAGONXI\PC4Xi\YoDragonXiOrg\WebSite\stock4xi\all2l4yo.html
»all2l4yo

Backup: Logic, HD-GUF and Server

January 9, 2015
ξ »analyse2photo4search
ξ »shoot2one4search.py
ξ meansize2ack4one corrected
ξ »gun2one4search.py
ξ »version4xi
ξ maxsize2file4one and max2short4one defined in version4xi.py
ξ trace updated and kept in above modules because they will and should NOT be generated automatically!

Module testing in Web:
»hunt2m4yo
ξ hunting images (medium)
»all2m4yo
ξ all medium images - images presenting a folder in SkyDrive deleted not to repeat them

Module testing in Fastblack:
ξ Pipe4Xi,Process4Xi, Queue4Xi <-- multiprocessin services by Multiprocessing4Xi
ξ print4xi, Print4Xi <-- trace services by Multiprocessing4Xi
ξ F:\temp\yophotos\test <- image folders copied into this folder
ξ »zen2dance4you02july2013 (1).JPG
ξ an image in the server
ξ F:\temp\yophotos\test\index2xxxxxxxx4yo.html <-- hyperlinks generated
ξ E:\STUDIO4XI\Python\3.3\temp\analyse2photo4search.txt <-- textual trace; watch failed/FAILED erros
ξ »sense-analyse2photo.xml
ξ »reason-analyse2photo
ξ »ace-analyse2photo
ξ XML trace produced

Backup: Haumea, HD-GUF and Server

January 8, 2015
ξ »analyse2photo4search
ξ utilized to verify image names to have proper index names (1) ... (n)
ξ ftp uploaded images with right index-names to yourdragonxi.org server
ξ uploaded images with right index-names to OneDrive of postmaster (large) and SEC (small)
ξ compared images at yourdragonxi.org to those at OneDrive
ξ »shoot2one4search.py
ξ optimized image names into (n) to minimize repeating promts and thereby speeded access to images
ξ accepted the fact that images will not be read and thereby will get written in folder order due to walkthrough
ξ »gun2one4search.py
ξ »version4xi
tests:
ξ F:\temp\yophotos\test <-- contained folders to be tested
ξ F:\temp\yophotos\test\index2xxxxxxxx4yo.html <-- HTML file file:///F:/temp/yophotos/test/index2xxxxxxxx4yo.html created by analyse2photo4search.py
ξ https://www.yourdragonxi.org/web/temp/images/medium/z/zen2dance4you02july2013/zen2dance4you02july2013%20(3).JPG <-- example link to image in server from index2xxxxxxxx4yo.html
ξ F:\temp\yophotos\medium <-- input to F:\temp\yophotos\test
ξ J:\PHOTOS\yodragonxiorg\web\temp\images\jpg\server\medium <-- input to F:\temp\yophotos\medium <=> www.yourdragonxi.org medium photos
ξ J:\PHOTOS\yodragonxiorg\web\temp\images\jpg\server\large <-- input to F:\temp\yophotos\large <=> www.yourdragonxi.org large photos
ξ F:\OneDrive\SmallSmart\postmaster\Images\large <-- OneDrive large images of postmaster
ξ F:\OneDrive\SmallSmart\sec\Images\medium <-- OneDrive medium images of secretary

Backup: Enceladus, HD-GUF and Server

January 7, 2015
ξ »version4xi
ξ 'base2build4hyperlink': 'https://www.yourdragonxi.org/web/temp/images/medium/',
ξ »analyse2photo4search
ξ »shoot2one4search.py
ξ built web hyperlinks, abonded the idea to print folder headers
ξ »gun2one4search.py

Backup: Saturn, HD-GUF and Server

January 6, 2015
ξ »version4xi
ξ 'base2shoot4one': None, <-- added to build local hyperlinks
ξ »analyse2photo4search
ξ added HTML file opening and close
ξ »shoot2one4search.py
ξ added HTML file writing and build2hyperlink4one function
ξ »gun2one4search.py

Backup: Uranus, HD-GUF and Server

January 5, 2015
ξ »analyse2photo4search
ξ changed the order how functions are being called to create delay for processes to complete before trace is being printed
ξ »shoot2one4search.py
ξ processes the given path in folder level and prints max 8 levels
ξ revealed the folder F:\temp\yophotos\medium\h\hunting\hunting21october2004\hunting21october2014 to be in wrong level!
ξ »gun2one4search.py
ξ walks trough the given path and saves folder paths to dictionary

Backup: Venus, HD-GUF and Server

January 4, 2015
ξ »analyse2photo4search
ξ p2one = Process4Xi(target=gun2one4search, args=(queue2one, pipe2one_consumer_channel, pipe2one_publisher_channel))
ξ above shows how the function gun2one4search is used as a target for multiprocessing4xi

ξ »gun2one4search.py
ξ dummy2one= DummyProcess4Xi(target=shoot2one4search,
ξ args =(queue2work4one, channel2consume4one, channel2publish4one, path2search4one))
ξ above shows how gun2one4search functions uses DummyProcess4Xi with shoot2one4search as target

ξ »shoot2one4search.py
ξ shoot2one4search function is run as a thread
ξ the above architecture allows the main program analyse2photo4search activate several processes
ξ with each process activating a separate thread
ξ thereby all available processor cores will be utilized with full power
ξ if a system processor does not have multiple cores the above architecture simulated threads
ξ allowing even modest computer to run their processor with optimal speed!

XML trace:
ξ »ace-analyse2photo.xml
ξ »reason-analyse2photo.xml
ξ »sense-analyse2photo.xml

Backup: Logic, HD-GUF and Server

January 3, 2015
ξ »analyse2photo4search
ξ uses command and control mechanism via queue and pipes
ξ calls gun2one4search directly as a function
ξ »gun2one4search.py
ξ activates shoot2one4search as thread by calling DummyProcess4Xi
ξ »shoot2one4search.py
ξ backup to server, Phoebe and HD-GUF

January 2, 2015
ξ »analyse2photo4search
ξ »gun2one4search.py
ξ »shoot2one4search.py
ξ edited readier to be produced by software - text string None is to be specially processed
ξ programmed and tested command and control with Queue4Xi and Pipe4Xi
ξ backup to server, Enceladus and HD-GUF

January 1, 2015
ξ decided to explore the idea the Scope4Xi library uses (Xi={APU...GPU...ZPU} and the virtual DRAGON)
ξ »version4xi.py of Studio4Xi
ξ »version4xi.py of Scope4Xi
ξ verified to be ok by comparing to the one in Studio4Xi to that of Scope4xi
ξ »analyse2photo4search
ξ add command and control with Queue4Xi and Pipe4Xi try multiprocessing tests
ξ »gun2one4search.py
ξ added import version4xi which is mandatory to use the multiprocessing4xi library services
ξ add command and control with Queue4Xi and Pipe4Xi once the caller is ready for it
ξ solve import DummyProcess4Xi
ξ »shoot2one4search.py
ξ added import version4xi which is mandatory to use the multiprocessing4xi library services
ξ add use of multiprocessing4xi
ξ backup to server, Titan and HD-GUF

December 31, 2014
ξ »analyse2photo4search
ξ first tests using functions directly and one direction
ξ »gun2one4search.py
ξ first tests - unresolved why import DummyProcess4Xi fails ?
ξ »shoot2one4search.py
ξ first tests with function calls
ξ backup to server, Saturn and HD-GUF

December 30, 2014
ξ »analyse2photo4search
ξ designing modules for command and control via named pipes and queues to analyse eight(8) different photo stores at the same time
ξ »gun2one4search.py
ξ ...
ξ »gun2eight4search.py
ξ each will use DummyProcess4Xi to activate shoot2one4search function allowing the main program analyse2photo4search.py to continue without having to wait
ξ »shoot2one4search.py
ξ ...
ξ »shoot2eight4search.py
ξ target functions will perform a specified search as a thread
ξ »version4xi.py

December 29, 2014
ξ »analyse2photo4search
ξ »version4xi.py
ξ created pipes and queues to process files concurrently using multiprocessing4xi library
ξ »test_sphere4xi.py
ξ »gun2one4xi.py
ξ »shoot2one4xi.py
ξ models how to use Pipe4Xi and Queue4Xi for command and control with multiprocessing

December 19, 2014
ξ »analyse2photo4search
ξ »version4xi.py
ξ designed distributed architecture to optimize hard disk speed and multi-core processor utilization with multiprocessing4xi library
ξ R:\Backup\studio4xi <-- backup; also uploaded to server

ξ C:\Windows <-- Local Disk for Windows 8.1
ξ D:\python33 <-- Python compiler
ξ E:\STUDIO4XI\Python\3.3\src <-- Innovation <-- Python source programs
ξ E:\STUDIO4XI\Python\3.3\temp <-- textual trace
ξ E:\WEB\xml <-- XML trace

ξ J:\PHOTOS\yodragonxiorg\web\temp\images\jpg\server\medium <-- Sun; FTP downloaded; images are stored also in OneDrive!
ξ 10,528 Files, 334 Folders <-- images locally in PC
ξ E:\DRAGONXI\WebFaction\Web306\FTPWeb306\home\icefellow\webapps\yodragonxiorg\web\temp\images\medium
ξ 10,528 Files, 333 Folders <-- images uploaded to web server, domain www.yourdragonxi.org
ξ folder x is missing because it is empty

ξ F:\temp\yophotos\medium <-- Saturn <-- (1)
ξ G:\temp\yophotos\medium <-- Titan <-- (3)
ξ H:\temp\yophotos\medium <-- Enceladus <-- (5)
ξ I:\temp\yophotos\medium <-- Phoebe
ξ J:\temp\yophotos\medium <-- Sun (20-40Mb/s) <-- (0) original images
ξ K:\temp\yophotos\medium <-- Theia (10-50Mb7s) <-- (7)
ξ L:\temp\yophotos\medium <-- Haumea (10-20Mb/s) <-- work
ξ M:\temp\yophotos\medium <-- Logic (x Mb/s) <-- work
ξ N:\temp\yophotos\medium <-- Venus (10Mb/s) <-- (8)
ξ O:\temp\yophotos\medium <-- Jupiter <-- (6)
ξ P:\temp\yophotos\medium <-- Kelvin (2-30MbMb/s) <-- Kelvin (www.dragonxi.com Zope/Plone 9090)
ξ Q:\temp\yophotos\medium <-- Taiko <-- (4)
ξ R:\temp\yophotos\medium <-- Uranus <-- (2)
ξ U:\temp\yophotos\medium <-- HD-GDU3 (USB Disk) <-- slow

December 17, 2014
ξ »add2index4xi
ξ adds index.html files as default, skips analysis by default leaving option to rough analysis
ξ »version4xi.py

December 12, 2014
ξ »add2index4xi
ξ programmed to add index.html file into each folder to prevent content misusage at www.yourdragonxi.org site
ξ analyzes content creating dictionaries to be printed to classify content
ξ categorized three levels of content

December 11, 2014
ξ »build2hyperlink4content
ξ »build2hyperlink4index
ξ »version4xi
ξ hit the problem using Sun(J:) drive whereas having photos in the same drive (E:\temp\large\) worked!
ξ simultaneously content was being uploaded to OneDrive and it has tendency to cause problems locally!
ξ created hyperlinks for large photos d�wnloaded from OneDive to be FTP uploaded to yourdragonxi.org

November 3, 2014
ξ parse2all4xi.bat command added to parse both Scope4Xi, Studio4Xi and Multiprocessing4Xi with one command

September 16, 2014
ξ »macro4xi.py
ξ »version4xi.py
ξ »index2verb4program
ξ reviewed how macros for programming are being created and updated the embedded documentation

September 6, 2014
ξ »get2sense4xi
ξ »version4xi.py
ξ reviewed - the existing one is a smart by creating modified output as defined and automatically also building put and get command files!
ξ added China to be sensed in hardware

September 5, 2014
ξ cancelled the idea to use weasyprint because it does not run with Python 3.3
ξ from setuptools import setup, find_packages in setup.py failed

September 3, 2014

Explored converting sense html files to pdf to access content from OneDrive which only shows raw html
ξ Python libraries required: html5lib and six
ξ added to D:\python33\Lib in FastBlack
ξ hit "cannot import name with_metaclass" in interactive Python which did succeed to start command import html5lib
Installed in FastBlack
ξ G:\sw\weasyprint4xi <-- converts from html to pdf/png
ξ G:\sw\cygwin <-- unzips - for example tar - xf /cygdrive/g/Download/SixPython/six-1.7.3.tar.gz <-- ** unzips to G:\sw\cygwin\bin **
ξ G:\Download\CygWin\setup-x86_64.exe <-- used to install more components such as tar
ξ to be explore where to keep html5lib and six libraries, for example having in separate own drive and folder as multiprocessingxi might be better!

Explored how to use Cygwin in FastBlack command mode
ξ Sec@fastblack ~~ <-- puts you in C: drive!
ξ $ cd g: <-- G:
ξ $ cd cygwin
ξ $ cd bin <-- this is where all CygWin commands are!
ξ $ ls
ξ $ tar --help
ξ $ tar - xf /cygdrive/g/Download/SixPython/six-1.7.3.tar.gz <-- nb1: /cygdrive in path ! nb2: output folder not defined, creates in /bin!

Uploaded downloaded zip files to OneDrive of CTO into Sw4Xi\Download folder

May 28, 2014
ξ »find2html4dragon
ξ »find2log4icefellow
ξ »find2py4icefellow
ξ »find2py4scope
ξ »find2text4scope
ξ »find2txt4icefellow
ξ »find2xml4scope
ξ »find4bat
ξ »find4boost
ξ »find4cl
ξ »find4py
ξ »find4share
ξ »find4txt
ξ »find4xi
ξ »find4zap
ξ »version4xi.py
ξ tested all find modules
ξ monthly backups

May 28, 2014
ξ »find4py
ξ »find2html4dragon
ξ »find2log4icefellow
ξ »find2py4scope
ξ »find2text4scope
ξ »find2txt4icefellow
ξ »find2xml4scope
ξ »find4bat
ξ »find4boost
ξ »find4cl
ξ »find4share
ξ »find4txt
ξ »find4xi
ξ »find4zap
ξ optimized performance

May 27, 2014
ξ tested new platform independent modules both in Windows 7.1 and Windows 8.1
ξ »macro4xi.py
ξ
ξ »parsestudio4xi.py
ξ parsed Studio4Xi
ξ »parse2scope4xi.py
ξ parsed Scope4Xi
ξ »parse4xi.py
ξ parsed Multiprocessing4Xi
ξ »build2hyperlink4sense.py
ξ »find4py.py
ξ optimized speed
ξ »version4xi.py
ξ continued changing modules to platform independent

May 26, 2014
ξ »build2hyperlink4sense.py
ξ »version4xi.py
ξ started changing mofules to platform independent and used new ones for hardware sensing

May 16, 2014
ξ »build2hyperlink4sense.py
ξ changes sense// to sense/ althought browsers seemed to handle sense//
ξ for key2try in sorted(keys2try):
ξ »version4xi.py
ξ base2hyperlink4sense key changed
ξ created index-sense-xi2.html and left it to be built permanently

May 15, 2014
ξ »build2hyperlink4sense.py
ξ »version4xi.py
ξ created web hyperlinks and tuned layouts
locally generated:
ξ China4yo
ξ Country4yo
ξ EU
ξ ORG
ξ USA
locally integrated:
ξ SENSE IT!
web integrated:
»yoSENSE

May 14, 2014
ξ »build2hyperlink4sense.py
ξ programmed local links for China, country, EU, org and USA - all but MS IE of Win 8.1 could handle those!
ξ backup to Enceladus in fastblack

May 13, 2014
ξ »build2hyperlink4sense.py
ξ ORG programmed and ignored verb used instead of skipped to depict that html file may just belong to another dictionary
ξ added e (energy) and realm subdomains as domains
ξ added trace where a target is skipped to reveal possible errors in input
ξ programmed EU reporting

May 12, 2014
ξ »build2hyperlink4sense.py
ξ added country reporting
ξ omitted -xx- files which are used as models to build HTML files
ξ added warning about HTML files in xx folders where only command files (.bat) are necessary!
ξ deleted in server /sense HTML files in xx folders - same to be done in workstations!

May 9, 2014
ξ »build2hyperlink4sense.py
ξ programmed USA states and China province reporting

May 6, 2014
ξ »build2hyperlink4sense.py
ξ added trace to explore which kind of URLs are being used
ξ »version4xi.py
ξ »version2fastblack4xi.py
ξ »version2laptop4xi.py
ξ »version2riika4xi.py
ξ added ROOT4XI

May 6, 2014
ξ »build2hyperlink4sense.py
ξ added statistics

May 5, 2014
ξ »build2hyperlink4sense.py
ξ added country, language code, state and province dictionaries

May 3, 2014
ξ »build2hyperlink4sense.py
ξ embedded index-sense-xi2 creation

May 2, 2014
ξ »build2hyperlink4sense.py
ξ continued planning dictionaries to be built
ξ »find2py4icefellow.py
ξ edited to hunt xml path users
ξ »build2hyperlink4auto.py
ξ »build2hyperlink4content.py
ξ »build2hyperlink4index.py
ξ »version2fastblack4xi.py
ξ xml path changed to relative in above and also in others referring to absolute paths

April 26, 2014
ξ »build2hyperlink4sense.py
ξ started creating hyperlinks to sensing »yoSENSE
1. domain such as energy »Energy Sensing
2. country »Nuclear Sensing of Canada
3. language »Sentir Energie Nucleaire de Canada
4. organization »Nuclear Power Organizations
5. United States »UAS SENSE of United States
6. state »California's UAS Sensing
7. China »UAS Sensing of China
8 province »UAS Sensing of Shanghai (sh) in China

April 16, 2014
ξ »build2hyperlink4content.py
ξ added .laz and .las extension for lidar files
ξ »build2hyperlink4index.py
ξ »version4xi.py
ξ »index2mml4xi.html
ξ generated local hyperlinks with file protocol
ξ Windows 8.1 IE is the only browser not accepting local links because it does not accept I: (Apple was right)

April 15, 2014
Browser tests for map links
ξ Opera and Chrome hanled OK local HTML-files and hyperlinks
ξ IE and Filefox failed!

I:\MAP4XI\fi\mml\index2mml4fb.html <-- index file

Firefox [NACK]
file:///I:/MAP4XI/fi/mml/index2mml4fb.html <-- OK
i://MAP4XI//fi//mml//r5k/index2r5k4fb.html <-- *** error ***
Opera [ACK]
file:///I:/MAP4XI/fi/mml/index2mml4fb.html <-- OK
file:///I://MAP4XI//fi//mml//r5k/index2r5k4fb.html <-- OK
IE [NACK]
I:\MAP4XI\fi\mml\index2mml4fb.html <-- keeps the same(as in Win 7.1)
file:///I://MAP4XI//fi//mml//r5k/index2r5k4fb.html <-- *** error ***
Chrome [ACK]
file:///I:/MAP4XI/fi/mml/index2mml4fb.html <-- OK
file:///I://MAP4XI//fi//mml//r5k/index2r5k4fb.html <-- OK
Safari [NACK]
I:\MAP4XI\fi\mml\index2mml4fb.html <-- *** error *** claimed MS does not accept i:

April 14, 2014
ξ »build2hyperlink4content.py
ξ added .TIF and .tif extensions
ξ »build2hyperlink4index.py
ξ »version4xi.py
ξ »index2mml4fb.html
ξ built local indexes for maps
ξ SkyDrive URL to be solved, base address is: https://SkyDrive.live.com

April 7, 2014
ξ verified multiprocessing4xi and scope4xi to use temporary folders in platform independent way
ξ »version4xi.py
ξ »find4bat.py
ξ »find4py

January 13, 2014
ξ Windows 8.1 Enterprise Evaluation Build 9600 and Python 3.3. installed to d:\python33
ξ »version4xi.py
ξ run parse4xi, parse2studio4xi and parse2scope4xi
January 13, 2014
ξ »get2sense4xi.py
ξ »version4xi.py
ξ »SENSE IT!
ξ update sense for yourdragonxi.org

January 8, 2014
ξ »get2sense4xi.py
ξ programmed to upgrade input files to newer HTML-version
ξ added converting content management type hyperlinks automatically to HTML-hyperlinks
ξ »version4xi.py
ξ relative addresses are being used, which makes modules usage easier
ξ whereas using temp folder may require attension such as editing get2all.bat and put2all.bat in this case!
ξ update sense domains such as uas,ugs, arts, rd and gov - mission impossible manually without this module!

January 6, 2014
ξ »get2sense4xi.py
ξ »version4xi.py
ξ gets HTML files used in sensing for editing and creates get2all.bat and put2all.bat
ξ bullet proof solution because Python script is used to get content
ξ dynamic and secure solution because get2all.bat and put2all.bat are created by Python script

January 6, 2014
ξ »get2sense4xi.py
ξ »version4xi.py
ξ gets HTML files used in sensing for editing into xx folder
ξ batch commands could not help managing several languages, neither to allow the flexibility Python script language can offer

December 15, 2013
ξ »build2carbage4content.py
ξ »version4xi.py
ξ created links to those file in the server without link
ξ they may be carbage - such as extra copies - but also private files to be kept in the server but without any link

December 12, 2013
ξ »ZIM <-- Admin for www.dargonxi.com
ξ exported main content both to server and to workstation
ξ E:\DRAGONXI\WebFaction\Web306\FTPWeb306\home\icefellow\webapps\dragon64\export <-- workstation
ξ /home/icefellow/webapps/dragon64/import <-- FTP uploaded here from workstation
ξ /home/icefellow/webapps/dragon64/import <-- used D:\sw\putty\putty.exe and DOS2UNIX for server ZIM/Plone to import, if required!
ξ /home/icefellow/tmp <-- the daily automatic backup will copy above .zexp files under zinstance into here!

December 11, 2013
ξ »build2hyperlink4content.py
ξ »yoAlphaImages
ξ updated photos and upgraded server content to be the same in backups

December 10, 2013
ξ »build2hyperlink4index.py
ξ »index2walk4yo.html
ξ built index to content in web sites to be used - small and fast one even with smart phones

December 9, 2013
ξ completed documentation of this file!

December 6, 2013
»Multiprocessing4Xi
»status2test4xi

»status2scope4xi
»index2scope4xi

»index2studio4xi.html
ξ verified

ξ »verify2uri4xi.py
ξ »verify2uri4xi.txt
ξ programmed line level reporting to help fixing errors quickly in HTML files
ξ discarded bold tag because its beginning is similar to that of line feed br
ξ »version4xi.py
ξ edited to verify different folders

ξ »parsestudio4xi.py
ξ »parse2studio4xi.txt
ξ »parse4xi.py
ξ »parse4xi.txt
ξ »parse2scope4xi.py
ξ »parse2scope4xi.txt
ξ parsed all libraries

December 5, 2013
ξ »verify2uri4xi.py
ξ verified URIs of this file!
ξ »version4xi.py
ξ defines input2verify4uri

December 4, 2013
ξ finished this document
ξ web hyperlinks to work using relative addresses
ξ between libraries hyperlinks to work by going up to the highest possible level first

December 3, 2013
ξ »find4py.py
ξ help to find program XML tags which identify source program types

November 29, 2013
ξ »parsing
ξ »macros
ξ »symbolize2actor4xi
ξ »verbalize4xi4xi
ξ »symbolize2verb4xi
ξ »walk4py
ξ »Zap
ξ » Fetching Scope4Xi Programs
ξ re-run and tuned this index file

November 28, 2013
ξ »index2cn4verbs.html
ξ added [#1] ... [#8] to depict translation /to link to the translating web page - [#9] to depict unresolved with link to search engine
ξ »chinese2verb4xi.py
ξ postponed to have own libraries to take care of translation and to produce colors for chinese veb symbols
ξ »calculate2chinese.html
ξ hard-coded example for testing chinese with calculate verb - may crash your browser!

November 27, 2013
ξ »index2cn4verbs.html
ξ list of verbs and their translation status to chinese
ξ »verbalize4xi.py
ξ .html extension omitted to clarify the list

November 26, 2013
ξ »symbolize2verb4xi.py
ξ »index2symbol4xi.html
ξ updated trace and improved index2verb4xi.html - decided not to embed anything more to this module to keep it as independent as possible

November 24, 2013
ξ »calculate2chinese.html
ξ not only verb but also cluster and super symbol chinese animation
ξ »295.html
ξ tested chinese characters as verb symbols - you get only subset, for example dragonize verb is missing!
ξ »build2get4content.py
ξ builds get2all4upload.bat to collect content such as photos scattered in subfolders into one folder for uploading

November 21, 2013
ξ »symbolize2actor4xi.py
ξ »index2actor4xi.html
ξ »cluster4xi.html
ξ »super4xi.html
ξ more information compared to those in /act
ξ »index2actor4xi.html
ξ »cluster4xi.html
ξ »super4xi.html
ξ original actor data
ξ »version4xi.py
ξ »actor2a4xi.py
ξ »noun4xi.py
ξ »cluster2a4xi.py
ξ »noun2cluster4xi.py
ξ »version4xi.py
ξ symbols for actors - unlike in case of verbs there are no keys for actors!
ξ cluster level symbols should do for actors instead of introducing too many symbols to be remembered!

November 20, 2013
ξ »symbolize2verb4xi.py
ξ »version4xi.py
ξ symbols for verbs programmed
ξ »parse2studio4xi.py
ξ »parse4xi.py
ξ + OK PARSING ..//..//..//..//studio4xi//python//3.1//src// MODULES 05:58:43 11/20/13 Pacific Standard Time
ξ + OK PARSING ..//..//..//..//sw4xi//python32//Lib//multiprocessing4xi// MODULES 06:00:29 11/20/13 Pacific Standard Time

November 18, 2013
ξ »index2verb4xi.html
ξ »abbreviate.html
ξ »acknowledge.html
ξ »dragonize.html
ξ »interface.html
ξ »venture.html
ξ »verbalize.html
ξ »wait.html
ξ »waive.html
ξ »wander.html
ξ »warn.html
ξ »web.html
ξ reviewed verb references and corrected corresponding verb2*4xi.py files in Multiprocessing4Xi

November 16, 2013
ξ »verbalize4xi.py
ξ corrected definition processing, run verbalize4xi and FTP uploaded

November 13, 2013
ξ »verbalize4xi.py
ξ »cluster4xi.html
ξ the prompt for super-name corrected

October 28, 2013
ξ »build2hyperlink4content.py
ξ updated embedded documentation and used to create HTML and get the latest photos FTP-uploaded to server

October 28, 2013
ξ »verbalize4xi.py
ξ added warning if a source python file refers to a free cluster
ξ »verb2r4xi.py
ξ read reference to cluster FREE 25 changed to 23 filing
ξ »verb4xi.py
ξ ClusterColor4Xi dictionary kept as it was
ξ »read.html
ξ reviewed with new cluster
ξ »cluster4xi.html
ξ reviewed
ξ »super4xi.html
ξ reviewed

October 15, 2013
ξ »act4xi.py
ξ »index2actor4xi.html
ξ »index2verb4xi.html
ξ added logo as in index for actors
ξ completed actors - Studio4Xi backups to all drives and FTP

October 13, 2013
ξ »act4xi.py
ξ »index2actor4xi.html
ξ OK for super4xi and cluster4xi
ξ »super4xi.html
ξ OK
ξ »cluster4xi.html
ξ OK
ξ »version4xi.py
ξ added act2studio
ξ »verbalize4xi.py
ξ modified documentation

October 12, 2013
ξ »verbalize4xi.py
ξ OK - table format showing not only textual but also colors as well as symbol instead of number as corresponding .png image!
ξ »index2verb4xi.html
ξ OK
ξ »super4xi.html
ξ OK
ξ »cluster4xi.html
ξ OK

October 10, 2013
ξ »verbalize4xi.py
ξ produced index2verb4xi.html for all verbs as well as for cluster4xi.html and super4xi.html
ξ »index2verb4xi.html
ξ updated verbalize4xi.bat to first delete cluster4xi.html, super4xi.html and index2verb4xi.html
ξ »cluster4xi.html
ξ »super4xi.html
ξ backups to ALL drives H: included + FTP upload to server + backups to dragonxi + download at RiikaPC

October 9, 2013
ξ »verbalize4xi.py
ξ »cluster4xi.html
ξ »super4xi.html
ξ added cluster and supercluster information
ξ »tune.html
ξ added cluster and supercluster information to verbs and header with version and time for html file
ξ modified to generate all verbs from multiprocessing4xi library instead of temporary test folder

October 7, 2013
ξ »verbalize4xi.py
ξ »show.html
ξ »set.html
ξ »skip.html
ξ created HTML presentation for each verb

October 1, 2013
ξ »image2canvas4test.html
ξ drew an image to canvas with javascript to explore verb symbol drawing on canvas

September 20, 2013
ξ »verbalize4xi.py
ξ »show.html
ξ added all tenses (1...4)

September 19, 2013
ξ »verbalize4xi.py
ξ added attributes reference, definition, symbol and cluster
ξ corrected statistics

September 18, 2013
ξ »verbalize4xi.py
ξ removed reserved tag usage to get it passed by parse2studio4xi.py
ξ »verb2z4xi.py
ξ »verb2s4xi.py
ξ »verb2_4xi.py
ξ selected test source programs to be used to generate HTML files
ξ »_pertain.html
ξ »show.html
ξ checked generated HTML files to have tense combinations (which is a challenge to handle!)
ξ »image2canvas4test.html
ξ »hello2canvas4test.html
ξ explored how to use HTML 5 canvas to display verb colors
ξ hit the problem with old browser which does not support canvas
ξ decided to use old browser locally because it displays file paths well and use newer browsers with web content

ξ »superclustercolor4xi.txt
ξ »clustercolor4xi.txt
ξ created to remember cluster and supercluster colors

September 17, 2013
ξ »macro4xi.py
ξ created program macros
ξ »version4xi.py
ξ »verbalize4xi.py
ξ started to mine verbs in multiprocessing4xi library and to create HTML-documents
ξ started testing with two source files verb2_4xi.py and verb2z4xi.py copied to temp folder

September 16, 2013
ξ »parse4xi.py
ξ »parse4xi.txt
ξ parsed multiprocessing4xi library - no modification - and added usage instructions inside parse4xi.py
ξ »parse2scope4xi.py
ξ »parse2scope4xi.txt
ξ added tags as comments to the end to get this module passed by parsestudio4xi.py
ξ »buffer4xi.py
ξ parsed scope4xi library - corrected buffer4xi.py - and added usage instructions inside parse2scope4xi.py
ξ »parsestudio4xi.py
ξ »parse2studio4xi.txt
ξ parsed studio4xi modules, added usage instructions and corrected tagging also in this module
ξ »dragonize2scope4xi.py
ξ »fetch2dragon4xi.py
ξ »generate2dragon4xi.py
ξ »photo4xi.py
ξ parsed studio4xi library - corrected tags in above modules - and added usage instructions inside parsestudio4xi.py

August 29, 2013
ξ »build2hyperlink4content.py
ξ built hyperlinks for the latest photos and updated its embedded usage documentation
ξ »version4xi.py
ξ modified for each build2hyperlink4content run

June 2, 2013
ξ monthly backups
ξ »generate3image4scope.py
ξ »version4xi.py
ξ generated Scope4Xi 3D image objects with their test modules for processing units {BPU ... GPU ... ZPU}

June 1, 2013
ξ backup Studio4Xi to V and USB(H:)- FTP upload plus backup L:\JOB to F:
ξ »generate2image4scope.py
ξ »version4xi.py
ξ generated Scope4Xi 2D image objects with their test modules for processing units {BPU ... GPU ... ZPU}

May 31, 2013
ξ backup Studio4Xi to F and USB(H:)- FTP upload plus backup L:\JOB to F:
ξ »generate2kernel4scope.py
ξ »version4xi.py
ξ generated Scope4Xi kernel objects with their test modules for processing units {BPU ... GPU ... ZPU}

May 30, 2013
ξ backup Studio4Xi to F and USB(H:)- FTP upload plus backup L:\JOB to F:
ξ »generate2sampler4scope.py
ξ »version4xi.py
ξ generated Scope4Xi sampler objects with their test modules for processing units {BPU ... GPU ... ZPU}

May 29, 2013
ξ backup Studio4Xi to D and USB(H:)- FTP upload plus backup L:\JOB to F:
ξ »generate2event4scope.py
ξ »version4xi.py
ξ generated Scope4Xi event objects with their test modules for processing units {BPU ... GPU ... ZPU}

May 28, 2013
ξ backup Studio4Xi to V and USB(H:)- FTP upload plus backup L:\JOB to F:
ξ »generate2commandqueue4scope.py
ξ »version4xi.py
ξ generated Scope4Xi commandqueue objects with their test modules for processing units {BPU ... GPU ... ZPU}

May 27, 2013
ξ backup Studio4Xi to F and USB(H:)- FTP upload plus backup L:\JOB to F:
ξ »generate2device4scope.py
ξ »version4xi.py
ξ generated Scope4Xi device objects for processing units {BPU ... GPU ... ZPU}

May 26, 2013
ξ backup Studio4Xi to D and USB(H:)- FTP upload plus backup L:\JOB to F:
ξ »generate2context4scope.py
ξ »version4xi.py
ξ generated Scope4Xi context objects for processing units {BPU ... GPU ... ZPU}

May 24, 2013
ξ backup Studio4Xi to D and USB(H:)- FTP upload plus backup L:\JOB to D:
ξ »generate2buffer4scope.py
ξ »version4xi.py
ξ generated Scope4Xi buffer objects for processing units {BPU ... GPU ... ZPU}

May 23, 2013
ξ backup Studio4Xi to V and USB(H:)- FTP upload plus backup L:\JOB to V:
ξ »generate2program4scope.py
ξ generated Scope4Xi program objects anf their test modules for processing units {BPU ... GPU ... ZPU}

May 12, 2013
============================================================================================================================================
(Step 33A/33) OF PARSE2SCOPE4XI PARSED TOTALLY 36 TAGS IN : 314 MODULES 03:35:47 05/12/13 Pacific Daylight Time
(Step 33B/33) OF PARSE2SCOPE4XI + OK PARSING ..//..//..//..//..// scope4xi//041721//zap//lib// MODULES 03:35:47 05/12/13 Pacific Daylight Time
(Step 33C/33) OF PARSE2SCOPE4XI + OK EXPLORING FOLDER ..//..//..//..//..// scope4xi//041721//zap//lib// 03:35:47 05/12/13 Pacific Daylight Time
============================================================================================================================================
ξ »parse.py

May 3, 2013
ξ support started to the new Scope4Xi Release 17.21

April 30, 2013
ξ supports the latest multiprocessing4xi

April 29, 2013
ξ version backups!

April 23, 2013
ξ normal backup to L: and M:(USB) - FTP upload changed ones - macros also this time!
ξ »to-be-done
ξ added idea to automated trace embedding into multiprocesssing4xi programs

April 17, 2013
ξ normal backup to F: and M:(USB) - FTP upload changed ones - macros also this time!
ξ »macro4xi.py
ξ macro4xi.py run to include new verbs

March 28, 2013
ξ monthly backup
ξ supporting the latest multiprocessing4xi as well as building hyperlinks for content

March 13, 2013
ξ normal backup to L: and M:(USB) - FTP upload changed ones!
ξ »macro4xi.py
ξ »version4xi.py
ξ macro4xi.py upgraded to use version4xi.py

February 22, 2013
ξ »build2hyperlink4content.py
ξ »version4xi.py
ξ added audio file content

February 17, 2013
ξ »parse4xi.py
ξ parsed tests for multiprocessing4xi

February 1, 2013
ξ »build2hyperlink4content.py
ξ »version4xi.py
ξ added documentation for photo processing workflows

January 9, 2013
ξ »parse4xi.py
ξ parsed the latest milestone of multiprocessing4xi

January 1, 2013
ξ »parse4xi.py
ξ parsed ugraded multiprocessing4xi

December 19, 2012
ξ offered services for Python 3.3 conversion of »Multiprocessing4Xi

November 26, 2012
ξ »find2html4dragon.py
ξ »version4xi.py
ξ verification support for yoUAS html links

November 21, 2012
ξ »photo2i4xi.py
ξ continue creating test cases for each alphabet
ξ consider adding path as the first key into the knowledegebase - current structure depicts files with the same name
ξ function handling files is being called when directories are being walked through and the whole path is passed to function
ξ instead of repeating path information consider building dictionary2path and referring to it

November 20, 2012
ξ »photo4xi.py
ξ »photo2_4xi.py
ξ »photo2h4xi.py
ξ improved knowledgebase, develop test code for various indexing and naming practises and started to create test data for each alphabet
ξ discovered that file name may not directly relate to directory where it is located
ξ backup and FTP download to D: and USB

November 19, 2012
ξ »photo4xi.py
ξ photo content management
ξ »photo2_4xi.py
ξ »photo2a4xi.py
ξ ...
ξ »photo2z4xi.py
ξ photo modules for each alpha

October 24, 2012
ξ supporting multiprocessing4xi conversion to Python 3.3. and to embed non-Windows (Apple OS, Unix, Linux ...) code dragonizing

October 9, 2012
ξ converted to Python 3.3
ξ updated go3studio4fb.bat, iceautoexec.bat,
ξ »find4py.py
ξ by searching refer4xi reference = "connection.py" found one can find dragonized modules having been used connection.py module
ξ multiprocessing services with dragonized trace »Multiprocessing4Xi
ξ #011

October 1, 2012
ξ reviewed all

September 19, 2012
ξ »build2hyperlink4content.py
ξ upgraded to minimize HTML file by shortening URL name and modified paths for Linux server
ξ .png and .PNG added as accepted image types although most of them are jpg type

September 17, 2012
ξ »build2hyperlink4content.py
ξ builds hyperlinks for content objects such as photos

September 5, 2012
ξ »check2size4file.py
ξ checks file size and produces statistics to resize image files for uploading to server
ξ uses dictionary to processes both jpg and bmp extensions - both in small and capital letter
ξ »version4xi.py
ξ used to set a subfolder to be checked
ξ note: no multiprocessing4xi modules such as print4xi.py, pickle2c4xi.py needed to be modified due to the trace settings!

June 2, 2012
ξ »generate2dragon4xi.py
ξ processed business plan HTML files which had embedded # anchor to external files and nw kind of anchor and image combinations
ξ improved failed handling by adding file to be processed and also statistics
ξ links to folders were replaced by links to corresponding index files to be able to load anchored file

May 28, 2012
ξ »generate2dragon4xi.py
ξ programmed handling mini anchors
ξ checked the whole folder /spec/ with all series and formulas

May 28, 2012
ξ »generate2dragon4xi.py
ξ added image source link processing and skipping www.yourdragonxi.org
ξ succeeded to check lambda and epsilon series portal links, image references and list external http: protocol links!
ξ external hyperlinks collected to knowledgebase and listed (opening URL failed with Python)

May 27, 2012
ξ »generate2dragon4xi.py
ξ succeeded to find with this module wrong anchor links into other files in the same folder in four lambda series business device files
ξ wiki links remained unchecked because one has to manage the whole web portal structure to test all kinds of portal links!
ξ added kb4site into generate2dragon4xi.py to define web portal structure - goal is to have only small subset in job folder under test
ξ succeeded to check all lambda series business device files with portal links to the whole local site!

May 26, 2012
ξ »generate2dragon4xi.py
ξ generates new updated objects from defined ones such as HTML file objects
ξ »fetch2dragon4xi.py
ξ fetches defined object(s) such as HTML files or TARGETs from dragon4xi folders

January 2, 2012
ξ »generate2kernel4scope.py
ξ generated kernel objects for all processing units

December 17, 2011
ξ »generate2program4scope.py
ξ generated program objects with their testing modules to {APU ... ZPU} processing units

October 28, 2011
ξ »build2scope4xi
ξ should build exe files inside scope4xi - however we must wait Python 3.3. bug with marshal to be fixed !

ξ continued »Generating Image Programs for Devices
ξ both 2D and 3D image modules and their test modules generated automatically and thereafter tested in Scope4Xi!

October 21, 2011
ξ »generate2image4scope.py
ξ upgraded to produce program only to selected devices based on defitions of ActKB4scope in version4xi.py
ξ generated bpu2image4xi.py ... zpu2image4xi.py one by one just by edit corresponding ActKB4scope line
ξ »print4xi.py
ξ fixed bug in set trace method - now just tailor2trace4studio() is enough to tailor trace because Print4Xi __init__ sets tracing!
ξ »version4xi
ξ added ActKB4scope to control to which device output is generated
ξ »WEB4Xi

October 20, 2011
ξ continued programming to »generate 2D image programs to all devices
ξ deployed 2D image modules »deployment of 2D image programs to scopexi
ξ update bacth files and tried to compile generated 2D image programs
ξ text file became 4.5 gigabytes, XML generation took almost 8gb RAM !
ξ need to select to which devices programs are to be generated and first to generate to ZPU (NOT to APU) device!

October 18, 2011
ξ started work »Generating Image Programs for Devices
ξ changed usage of folders so that job is done in L:\job\041721\studio4xi
ξ thereby it is easier to analyze each command, its input and output as well as deploy output to scope4xi folder

ξ »Dragonizing
ξ created image processing modules for dragon device to be used as the base device to generate code for apu ... zpu
ξ »dragon2image4xi.py
ξ »dragon2image4xi5test.py
ξ »dragon3image4xi.py
ξ »dragon3image4xi5test.py
ξ »version4xi.py
ξ programmed possibility to generate dragon module so that it imports from other modules to get it compiled

October 17, 2011
ξ »Dragonizing
ξ programmed to create image processing modules for dragon device to be used as the base device to generate code for apu ... zpu
ξ »Fetching Scope4Xi Programs
ξ dragonized trace with XML output
ξ »print4xi.py
ξ fixed bug in reason method which caused verbs in messages such as (Step 1/8) got the verb to be skipped!
ξ »xml_trace_ace4xi.py
ξ »xml_trace_reason4xi.py
ξ »xml_trace_sense4xi.py
ξ updated trace
ξ »Pickling
ξ Studio4Xi module added
ξ »Actors
ξ Studio4Xi module added
ξ »Version4xi.py
ξ upgraded to have multiprocessing4xi

October 13, 2011
ξ »Fetching Scope4Xi Programs
ξ programmed and tested fetching of scope modules

October 12, 2011
ξ started to develop program to »generate Scope Programs
ξ created »WEB4Xi
ξ decided to create automatic software generation for Scope4Xi in this studio
ξ existing modules mainly helped to find something in test outputs, source programs or to parse source programs in all libraries

October 10, 2011
ξ »print4xi.py
ξ »apu2image4xi.py
ξ »apu2image4xi5test.py
ξ 2D and 3D image processing modules of Scope4Xi for APU embedded in trace
ξ »parse2scope4xi
ξ »parse2scope4xi.txt
ξ parsed scope4xi modules - explored as a model
ξ »verb4xi.py
ξ »verb2a4xi.py
ξ explored as a model

September 8, 2011
ξ »parse2scope4xi
ξ »parse2scope4xi.txt
ξ parsed scope4xi modules
ξ »queue4xi.py
ξ »queue_arena4xi.py
ξ programmed queue tests with image files - concluded that queue requires ASCII data
ξ you can put and get file paths and messages but you can NOT put and get image files !

September 7, 2011
ξ »arena4xi.py
ξ »test_arena4xi.py
ξ explored Arena4Xi objects, memory maps and mapping images - not supported enough for Scope4Xi in Python !
ξ many Python libraries such as Image and PNG don't support the latest Python compiler

August 30, 2011
ξ »print4xi.py
ξ added scope modules to trace

August 10, 2011
ξ »parse2scope4xi
ξ »parse2scope4xi.txt
ξ parsed scope4xi modules
ξ »print4xi.py
ξ integrated scope modules to trace

February 24, 2011
ξ »parse2scope4xi
ξ parsed scope4xi modules
ξ »zapimport2ball4xi.py
ξ »import2ball4xi.py
ξ »yoke4xi.py
ξ »version4xi.py
ξ paths updated to be defined in version4xi.py and imported by others

February 23, 2011 - Scope4Xi Started!
ξ »zapimport2ball4xi.py
ξ »import2ball4xi.py
ξ »yoke4xi.py
ξ »ace-test-zskeleton4xi.html
ξ »reason-test-zskeleton4xi.html
ξ »sense-test-zskeleton4xi.html
ξ imported all zapped sense-, reason and ace zap modules and created HTML5-files - above three from one test case - version to be added from Studio!

February 22, 2011 - Multiprocessing4xi with Studio4Xi ICED!

ξ compiled all zap-modules and also verified zap-source file links in Studio4Xi
ξ generated ALL scope files - see test_zap2actor4xi.bat, test_zap2noun4xi.bat and test_zap2verb4xi.bat!
ξ checked with Studio4Xi using find-modules such as find4xi.py!
ξ created missing fields message (11), 12 and 13 for zapped verbs and nouns

February 18, 2011

ξ »actor4xi.py
ξ »hello_world4xi.py
ξ tailored trace for forkingpickler4xi to update forkingpickler4xi.py trace comments
ξ »get_preparation_data4xi.py
ξ »gun4xi.py
ξ »hello_pipe4xi.py
ξ »noun4xi.py
ξ »original_dir4xi.py
ξ »pickle4xi.py
ξ »popen4xi.py
ξ »print4xi.py
ξ »process4xi.py
ξ »test_constant_connection4xi.py
ξ upgraded for Python3.3: trace data - XML name space in ALL test programs
ξ commanded run4xi.bat to compile and test all prgrams!
ξ »test_all_methods4xi.py
ξ »all_methods4xi.py
ξ upgraded to handle manager objects!
ξ »test_print4xi.pypy
ξ »print4xi.pypy
ξ a bug fixed in initializing

Studio4Xi
ξ »find4py.py
ξ used to find references to older Python 3.3 version - very useful!
ξ »parse4xi
ξ parsed all dragonized multiprocessing4xi source files!
ξ created assist2studiom1 ... m3.bst from keyboard profiles
ξ »find4xi.py
ξ upgraded faster and used to trace errors after run4xi.bat

February 16, 2011
ξ Windows 7 64-bit Ultimate
ξ Python 3.3 - stores *.pyc files in __pychache__ subfolders in multiprocessing4xi library and also in other libraries!
ξ compiled and tested in the new environment
ξ »popen4xi.py
ξ tried and yielded del Popen4Xi._tls.process_handle #delete thread local storage handle - no harmful side effect detected & you have to yield!
ξ »test_dummy_process4xi.py
ξ upgraded to yield rather than fail with not implemented features
ξ »test_current_process4xi.py
ξ upgraded with more detailed trace and by adding try blocks

February 1, 2011 - Windows 64-bit Vista Ultimate
ξ »zapimport2ball4xi.py
ξ »import2ball4xi.py
ξ »yoke4xi.py
ξ yokes content to print and/or to file decreasing code lines in import2ball4xi.py module

January 27, 2011
ξ »zapimport2ball4xi.py
ξ zap depicts run/fire/perform/shoot - test is not used with applications
ξ defined path to xml files with path2xml4scope variable
ξ »import2ball4xi.py
ξ »xml_trace_sense4xi.py
ξ improved degugging for scope programs, which can require debug as parameter - at this phase dragonized trace has been done and can not be used!
ξ GOT BACK THE SECOND LCD SCREEN - ATI Catalyst Control Center OK - challenges with OS which required displays to be swapped !

January 26, 2011
ξ »zapimport2ball4xi.py
ξ »import2ball4xi.py
ξ Sope4Xi import accessing selected zap-module(s) and creating HTML-file
ξ tested with all zap-modules created by multiprocessing4xi
ξ succeeded to import and use multiprocessing4xi modules to have a module only in one place for maintenance
ξ »sense-test-zskeleton4xi.html
ξ only this one was kept - others moved to temporary folder - goal to generate this on demand and with the same name

January 25, 2011
ξ »import_zap
ξ solved how to dynamically define for Python where also to import by adding statement: sys.path.append('../lib/multiprocessing4xi')
ξ note that a relative path is given, which makes code more portable
ξ after that the following import works and is the simplest way to embed it into source programs: from process4xi import Process4Xi
ξ this solved the bigger issue how and where to locate applications such as telescope4xi.py!
ξ updated tips »TIPS

January 24, 2011
ξ »import_zap
ξ »sense-test-zskeleton4xi.html
ξ objects for each direction, layer and node

January 21, 2011
ξ »import_zap
ξ »sense-test-zskeleton4xi.html
ξ added HTML 5.0 features such as manifest for offline situations
ξ style sheets added
ξ defaults provided for message, actor and module

January 21, 2011
ξ »import_zap
ξ writes sense HTML file
ξ »sense-test-zskeleton4xi.html
ξ defines object and parameters - see source of HTML

January 18, 2011
ξ »import_zap
ξ upgraded to print embedded knowledgebases such as layer in nodes

January 17, 2011
ξ »import_zap
ξ upgraded to build dictionary from all zapped spheres and to print all fields
ξ had to develop with one LCD screen sent to service to get unusable pixels repaid - felt the lack of work space with only one screen - USB-displays might be handy!

January 11, 2011

zapped all scoped sense- reason- and ace-xml-files running three (3) command windows!
ξ Profile Moduler Tester [M3]
ξ Actors All Zap! t test_zap2actor4xi >e:\temptokatera\temp\test_zap2actor4xi.txt
ξ Nouns All Zap! t test_zap2noun4xi >e:\temptokatera\temp\test_zap2noun4xi.txt
ξ Verbs All Zap! t test_zap2verb4xi >e:\temptokatera\temp\test_zap2verb4xi.txt

ξ »import_zap
ξ programmed to import all sphere modules with unique names
ξ »zap2verb4xi.py
ξ »zap2verb4xi.py
ξ »zap2verb4xi.py
ξ changed naming of Python files and naming of Python modules created acceptable fo Python compiler
ξ »noun4x.pyi
ξ »verb4xi.py
ξ »actor4xi.py
ξ upgraded to be more robust when printing debug info

January 08, 2011

[1-OK] run all tests to produce the latest sense-, reason-, and ace-xml files wih the latest compiled sources!
Profiles:
ξ Utility Tester [M1] [M2] [M3]
ξ Commander4Xi [M1] [M2] [M3]
ξ Moduler Tester [M1] [M2] [M3]

[2-OK] scoped all sense-, reason-, and ace-xml-files - simultaneously in own window & all in one!
Profiles:
ξ Moduler Tester [M1] [M2] [M3]
ξ [M1] [M2] [M3]
ξ [M1] [M2] [M3]
ξ [M1] [M2] [M3]
ξ Reason All Files Scope! t test_coordinate4xi >e:\temptokatera\test_coordinate4xi.txt
ξ Ace All Files Scope! t test_noun4xi >e:\temptokatera\temp\test_noun4xi.txt
ξ Sense All Files Scope! t test_actor4xi >e:\temptokatera\temp\test_actor4xi.txt

[3-OK] zapped all scoped sense- reason- and ace-xml-files!
Profiles:
ξ Moduler Tester [M3]
ξ Actors All Zap! t test_zap2actor4xi >e:\temptokatera\temp\test_zap2actor4xi.txt
ξ Nouns All Zap! t test_zap2noun4xi >e:\temptokatera\temp\test_zap2noun4xi.txt
ξ Verbs All Zap! t test_zap2verb4xi >e:\temptokatera\temp\test_zap2verb4xi.txt

ξ »test_zap2verb4xi.py
ξ »reason-test-zskeleton4xi-zap.py
ξ zapped ok input file zap scope-reason-test-zskeleton4xi.xml
ξ »test_zap2noun4xi.py
ξ »ace-test-zskeleton4xi-zap.py
ξ zapped ok input file zap scope-ace-test-zskeleton4xi.xml
ξ scoped input file cluster statistics had bug direction 0 !
ξ run test_zskeleton4xi.py in the profile Utility Tester M1
ξ run test_noun4xi.py in the profile Moduler Tester M3 - new scoped ace files was ok i.e. ALL ace-files must be re-scoped !
ξ looked like false alarm in (Step 6B17B/33) OF ZAP0010TWO4XI *** FAILED TO PUT LAYER 0010 TO QUEUE0010TWO: ", key0010two): # 0x-27y-42z
ξ »zap2actor4xi.py
ξ got ok by »zap0010two4xi.py
ξ built sphere in the main contains ok the node: # SphereKB4Xi[ 2 ][ 10 ][ 0x-27y-42z ]: ...

January 06, 2011
ξ »test_zap2actor4xi.py
ξ COMPLETED ZAPPING ALL SCOPED SENSE-FILES »Zapped files
ξ updated several source programs created without Studio4Xi macros (which had eliminated errors)
ξ edited trace in several source programs to be in sync with the one defined for print4xi.py
ξ corrected erros revealed by Studio4Xi modulize4xi.py in macro data content (for example for program4xi-macro source was defines without .py extension)
ξ SENSE-LIFE-CYCLE 1) CREATE SOURCE 2) COMPILE 3) TEST CREATING SENSE-XML-FILES 4) SCOPE SENSE-XML-FILES 5) ZAP SCOPED SENSE-XML-FILES
ξ REASON-LIFE-CYCLE: 1) CREATE SOURCE 2) COMPILE 3) TEST CREATING REASON-XML-FILES 4) SCOPE REASON-XML-FILES
ξ ACE-LIFE-CYCLE: 1) CREATE SOURCE 2) COMPILE 3) TEST CREATING ACE-XML-FILES 4) SCOPE ACE-XML-FILES

January 04, 2011
ξ »test_zap2actor4xi.py
ξ run to create new zap modules
ξ »zap2actor4xi.py
ξ updated zap modules to have ack2debug = False
ξ removed reserved tags in comments because they affect to modulize4xi.py in Studio!
ξ »current_process4xi.py
ξ init_children_current_process4xi trace setting updated
ξ »hello_world4xi.py
ξ rerun hello_world4xi.py, because it uses init_children_current_process4xi function
ξ »test_noun4x.pyi
ξ »test_coordinate4xi.py
ξ »test_actor4xi.py
ξ rerun the program having the bug in trace: hello_world4xi.py
ξ rerun test_noun4xi.py, test_coordinate4xi.py and test_actor4xi.py thereby creating updated ace-, sense- and reason scope-files
ξ »zap2module4xi.py
ξ updated to handle special cases in source modules (plenty of them!)
ξ »find4zap.py
ξ run after each test_zap2actor4xi.py run to check that all links to modules are ok
ξ »modulize4xi.py
ξ updated to handle special cases
ξ »hello_world4xi.py

January 03, 2011
ξ »test_zap2actor4xi.py
ξ new zap files created - modules bound to actors now ok due to the new zap2module4xi.py
ξ »modulize4xi.py
ξ solved the challenge with unresolved modules during zapping scoped sense-files
ξ modulize4xi.py is automatically created zap2module4xi.py - used as the actor the one declared in methodize4xi-macro, for example init-of-ForkingPickler4Xi
ξ upgraded modulize4xi.py also to take the function and method names defined for compiler !
ξ »zap2module4xi.py
ξ »syncmanager4xi.py
ξ »heap4xi.py
ξ corrected trace usage and macro definitions - which running modulize4xi.py reveales
example:
ξ »scope-sense-all-methods4xi.xml
ξ __init__-of-ForkingPickler4Xi
ξ {(Step 1/7a) started; init-of-ForkingPickler4Xi-started: 08:15:30 10/21/10 Pacific Daylight Time}
ξ »sense-all-methods4xi.xml
ξ __init__{(Step 1/7a) started; init-of-ForkingPickler4Xi-started: 08:15:30 10/21/10 Pacific Daylight Time}

January 02, 2011
ξ »Zapped Programs
ξ ALL scoped sense files zapped and compiled!
ξ »test_zap2actor4xi.py
ξ new zap files created - documented not to zap too many scoped files in one run, unless trace is zeroed between zappings
ξ »zap2actor4xi.py
ξ added conditional dragon trace, because it is the amount of trace built inside print4xi.py which caused memory problems !
ξ »zap0000one4xi.py
ξ added conditional dragon trace to all direction one zap modules zap0000, 0001, 0010, 00100 ... 3300one4xi.py

December 30, 2010
ξ »test_zap2actor4xi.py
ξ set to process scoped hello_world4xi.py to solve big scoped files- adding virtual memory does not help - OS/Python virtual memory bug ?
ξ each zap module might be able release dictionary after putting it to queue ?!
ξ adding RAM might solve the problem
ξ trace .txt must be analyzed with Studio4Xi to analyze zapping hello_world4xi and bigger files

ξ »test_actor4xi.py
ξ »test_coordinate4xi.py
ξ »test_noun4xi.py
ξ run ALL to create NEW scoped files
ξ »actor4xi.py
ξ »noun4xi.py
ξ »verb4xi.py
ξ upgraded to use super 8 if cluster gives super 0
ξ »hello_world4xi.py
ξ limited trace for scoping and zapping
ξ »actor2i4xi.py
ξ added init_children_current_process4xi
ξ »test_zap2actor4xi.py
ξ programmed to create program embedding the sphere created and containing self-test logic for the dictionary
ξ »zap2actor4xi.py
ξ released memory by setting a dictionary to {} as soon as it was not used anymore
ξ changed Windows Vista 64-bit System Properties - Virtual memory from 8 490 MB in C (recommended 12 285 MB)
ξ E: available (FREE) 258 261 Mb = 240 Gb <-- 33960 MB, max 50940 MB
ξ D: available (FREE) 320 062 Mb = 271 Gb <-- 33960 MB, max 50940 MB
ξ E: available (FREE) 250 963 Mb = 233 Gb <-- 33960 MB, max 50940 MB
ξ F: available (FREE) 147 665 Mb = 144 Gb <-- 33960 MB, max 50940 MB
ξ another file existed with the file name d:\pagefile.sys <-- overwrote!
ξ adding virtual memory to each drive helped: Free Physical Memory(MB) stayed about 2000-2500 Mb
ξ Total Physical Mememo: 8190 MB, Cached ca. 2500 - 2700Mb, Free 2200-2500 Mb
ξ Kernel Memory (Mb) Total: 266Mb, Paged: 212 Mb, Nonpaged: 54Mb

December 29, 2010
ξ »test_zap2actor4xi.py
ξ programmed to create program embedding the sphere created and containing self-test logic for the dictionary
ξ »zap2actor4xi.py
ξ run to ALL scoped sense files !
ξ »after-fork4xi-zap.py
ξ »dummy-process4xi-zap.py
ξ »finalize4xi-zap.py
ξ »hello-pipe4xi-zap.py
ξ »sleep4xi-zap.py
ξ »sync-manager-test4xi-zap.py
ξ »test-after_fork4xi-zap.py
ξ »test-arena4xi-zap.py
ξ »test-constant-connection4xi-zap.py
ξ »test-constant-family4xi-zap.py
ξ »test-constant-forking4xi-zap.py
ξ »test-constant-heap4xi-zap.py
ξ »test-constant-logger4xi-zap.py
ξ »test-constant-managers4xi-zap.py
ξ »test-constant-pool4xi-zap.py
ξ »test-constant-process4xi-zap.py
ξ »test-constant-synchronize4xi-zap.py
ξ »test-constant-system4xi-zap.py
ξ »test-constant-util4xi-zap.py
ξ »test-cpu-corecount4xi-zap.py
ξ »test-format4xi-zap.py
ξ »test-kskeleton4xi-zap.py
ξ »test-logger4xi-zap.py
ξ »test-original-dir4xi-zap.py
ξ »test-server4xi-zap.py
ξ »test-skeleton-print4xi-zap.py
ξ »test-state4xi-zap.py
ξ »test-uskeleton4xi-zap.py
ξ »test-yskeleton4xi-zap.py
ξ »test-zskeleton4xi-zap.py
ξ »timeout4xi-zap.py
ξ »value-proxy4xi-zap.py
ξ »value-test4xi-zap.py
ξ automatically created zap-programs!

December 28, 2010
ξ »test_zap2actor4xi.py
ξ »zap2actor4xi.py
ξ origin and skeleton added to SphereKB4Xi
ξ the first link from skeleton node to the nearest node at each direction programmed to SphereKB4Xi
ξ the last link from skeleton node to the most far away node at each direction programmed to SphereKB4Xi

December 26, 2010
ξ »test_zap2actor4xi.py
ξ »zap2actor4xi.py
ξ SphereKB4Xi created

December 22, 2010
ξ »test_zap2actor4xi.py
ξ »zap2actor4xi.py
ξ verified and saved messages from all directions & all layers separate dictionary
ξ verified and saved dictionaries from all directions & all layers into separate dictionary

ξ »test_actor4xi.py
ξ »actor4xi.py
ξ run to all scoped sense xml-files to get class name to actors of method type

December 20, 2010
ξ »modulize4xi.py
ξ automatically creates zap2module4xi.py - a very valuable tool!
ξ »zap2module4xi.py
ξ ModuleKB2Zap4Xi mined by modulize4xi.py from source modules !
ξ »zap2actor4xi.py
ξ »test_zap2actor4xi.py
ξ tested with automatically in Studio4Xi generated zap2module4xi.py - all modules found ok!

December 18, 2010
ξ »zap2actor4xi.py
ξ verified layer 3200 to all directions - added try-blocks - unique naming of objects
ξ upgraded unique object names to help debugging - capabability to edit and compiler in different OS and hardware is a useful benefit!
ξ »test_zap2actor4xi.py
ξ tested layer 3200 to all directions
ξ »zap3200one4xi.py
ξ »zap3200two4xi.py
ξ »zap3200three4xi.py
ξ »zap3200four4xi.py
ξ »zap3200five4xi.py
ξ »zap3200six4xi.py
ξ »zap3200seven4xi.py
ξ »zap3200eight4xi.py
ξ verified layer 3200 operations

December 16, 2010
ξ »test_zap2actor4xi.py
ξ tested layer 3300 to all directions!
ξ »zap3300one4xi.py
ξ »zap3300two4xi.py
ξ »zap3300three4xi.py
ξ »zap3300four4xi.py
ξ »zap3300five4xi.py
ξ »zap3300six4xi.py
ξ »zap3300seven4xi.py
ξ »zap3300eight4xi.py
ξ »zap2actor4xi.py
ξ tailored message trace for level 3300

»print4xi.py
ξ fixed the problem trace was not got at layer 3300 to direction two
ξ updated tips »TIP 8: Getting trace to print

December 15, 2010
ξ »zap2actor4xi.py
ξ »test_zap2actor4xi.py
ξ upgraded all levels 0010, 0100 ... 3300 to all directions 1 .. 8

ξ »zap0000one4xi.py
ξ »zap0000two4xi.py
ξ »zap0000three4xi.py
ξ »zap0000four4xi.py
ξ »zap0000five4xi.py
ξ »zap0000six4xi.py
ξ »zap0000seven4xi.py
ξ »zap0000eight4xi.py

ξ »zap0000one4xi.py
ξ »zap0001one4xi.py
ξ »zap0010one4xi.py
ξ »zap0100one4xi.py
ξ »zap0200one4xi.py
ξ »zap0300one4xi.py
ξ »zap0400one4xi.py
ξ »zap0500one4xi.py
ξ »zap0600one4xi.py
ξ »zap0700one4xi.py
ξ »zap0800one4xi.py
ξ »zap0900one4xi.py
ξ »zap1000one4xi.py
ξ »zap1100one4xi.py
ξ »zap1200one4xi.py
ξ »zap1300one4xi.py
ξ »zap1400one4xi.py
ξ »zap1500one4xi.py
ξ »zap1600one4xi.py
ξ »zap1700one4xi.py
ξ »zap1800one4xi.py
ξ »zap1900one4xi.py
ξ »zap2000one4xi.py
ξ »zap2100one4xi.py
ξ »zap2200one4xi.py
ξ »zap2300one4xi.py
ξ »zap2400one4xi.py
ξ »zap2500one4xi.py
ξ »zap2600one4xi.py
ξ »zap2700one4xi.py
ξ »zap2800one4xi.py
ξ »zap2900one4xi.py
ξ »zap3000one4xi.py
ξ »zap3100one4xi.py
ξ »zap3200one4xi.py
ξ »zap3300one4xi.py

ξ »zap0000two4xi.py
ξ »zap0001two4xi.py
ξ »zap0010two4xi.py
ξ »zap0100two4xi.py
ξ »zap0200two4xi.py
ξ »zap0300two4xi.py
ξ »zap0400two4xi.py
ξ »zap0500two4xi.py
ξ »zap0600two4xi.py
ξ »zap0700two4xi.py
ξ »zap0800two4xi.py
ξ »zap0900two4xi.py
ξ »zap1000two4xi.py
ξ »zap1100two4xi.py
ξ »zap12000two4xi.py
ξ »zap13000two4xi.py
ξ »zap14000two4xi.py
ξ »zap15000two4xi.py
ξ »zap16000two4xi.py
ξ »zap17000two4xi.py
ξ »zap18000two4xi.py
ξ »zap19000two4xi.py
ξ »zap2000two4xi.py
ξ »zap2100two4xi.py
ξ »zap2200two4xi.py
ξ »zap2300two4xi.py
ξ »zap2400two4xi.py
ξ »zap2500two4xi.py
ξ »zap2600two4xi.py
ξ »zap2700two4xi.py
ξ »zap2800two4xi.py
ξ »zap2900two4xi.py
ξ »zap3000two4xi.py
ξ »zap3100two4xi.py
ξ »zap3200two4xi.py
ξ »zap3300two4xi.py

ξ »zap0000three4xi.py
ξ »zap0001three4xi.py
ξ »zap0010three4xi.py
ξ »zap0100three4xi.py
ξ »zap0200three4xi.py
ξ »zap0300three4xi.py
ξ »zap0400three4xi.py
ξ »zap0500three4xi.py
ξ »zap0600three4xi.py
ξ »zap0700three4xi.py
ξ »zap0800three4xi.py
ξ »zap0900three4xi.py
ξ »zap1000three4xi.py
ξ »zap1100three4xi.py
ξ »zap1200three4xi.py
ξ »zap1300three4xi.py
ξ »zap1400three4xi.py
ξ »zap1500three4xi.py
ξ »zap1600three4xi.py
ξ »zap1700three4xi.py
ξ »zap1800three4xi.py
ξ »zap1900three4xi.py
ξ »zap2000three4xi.py
ξ »zap2100three4xi.py
ξ »zap2200three4xi.py
ξ »zap2300three4xi.py
ξ »zap2400three4xi.py
ξ »zap2500three4xi.py
ξ »zap2600three4xi.py
ξ »zap2700three4xi.py
ξ »zap2800three4xi.py
ξ »zap2900three4xi.py
ξ »zap3000three4xi.py
ξ »zap3100three4xi.py
ξ »zap3200three4xi.py
ξ »zap3300three4xi.py

ξ »zap0000four4xi.py
ξ »zap0001four4xi.py
ξ »zap0010four4xi.py
ξ »zap0100four4xi.py
ξ »zap0200four4xi.py
ξ »zap0300four4xi.py
ξ »zap0400four4xi.py
ξ »zap0500four4xi.py
ξ »zap0600four4xi.py
ξ »zap0700four4xi.py
ξ »zap0800four4xi.py
ξ »zap0900four4xi.py
ξ »zap01000four4xi.py
ξ »zap01100four4xi.py
ξ »zap1200four4xi.py
ξ »zap1300four4xi.py
ξ »zap1400four4xi.py
ξ »zap1500four4xi.py
ξ »zap1600four4xi.py
ξ »zap1700four4xi.py
ξ »zap1800four4xi.py
ξ »zap1900four4xi.py
ξ »zap2000four4xi.py
ξ »zap2100four4xi.py
ξ »zap2200four4xi.py
ξ »zap2300four4xi.py
ξ »zap2400four4xi.py
ξ »zap2500four4xi.py
ξ »zap2600four4xi.py
ξ »zap2700four4xi.py
ξ »zap2800four4xi.py
ξ »zap2900four4xi.py
ξ »zap3000four4xi.py
ξ »zap3100four4xi.py
ξ »zap3200four4xi.py
ξ »zap3300four4xi.py

ξ »zap0000five4xi.py
ξ »zap0001five4xi.py
ξ »zap0010five4xi.py
ξ »zap0100five4xi.py
ξ »zap0200five4xi.py
ξ »zap0300five4xi.py
ξ »zap0400five4xi.py
ξ »zap0500five4xi.py
ξ »zap0600five4xi.py
ξ »zap0700five4xi.py
ξ »zap0800five4xi.py
ξ »zap0900five4xi.py
ξ »zap1000five4xi.py
ξ »zap1100five4xi.py
ξ »zap1200five4xi.py
ξ »zap1300five4xi.py
ξ »zap1400five4xi.py
ξ »zap1500five4xi.py
ξ »zap1600five4xi.py
ξ »zap1700five4xi.py
ξ »zap1800five4xi.py
ξ »zap1900five4xi.py
ξ »zap2000five4xi.py
ξ »zap2100five4xi.py
ξ »zap2200five4xi.py
ξ »zap2300five4xi.py
ξ »zap2400five4xi.py
ξ »zap2500five4xi.py
ξ »zap2600five4xi.py
ξ »zap2700five4xi.py
ξ »zap2800five4xi.py
ξ »zap2900five4xi.py
ξ »zap3000five4xi.py
ξ »zap3100five4xi.py
ξ »zap3200five4xi.py
ξ »zap3300five4xi.py

ξ »zap0000six4xi.py
ξ »zap0001six4xi.py
ξ »zap0010six4xi.py
ξ »zap0100six4xi.py
ξ »zap0200six4xi.py
ξ »zap0300six4xi.py
ξ »zap0400six4xi.py
ξ »zap0500six4xi.py
ξ »zap0600six4xi.py
ξ »zap0700six4xi.py
ξ »zap0800six4xi.py
ξ »zap0900six4xi.py
ξ »zap1000six4xi.py
ξ »zap1100six4xi.py
ξ »zap1200six4xi.py
ξ »zap1300six4xi.py
ξ »zap1400six4xi.py
ξ »zap1500six4xi.py
ξ »zap1600six4xi.py
ξ »zap1700six4xi.py
ξ »zap1800six4xi.py
ξ »zap1900six4xi.py
ξ »zap2000six4xi.py
ξ »zap2100six4xi.py
ξ »zap2200six4xi.py
ξ »zap2300six4xi.py
ξ »zap2400six4xi.py
ξ »zap2500six4xi.py
ξ »zap2600six4xi.py
ξ »zap2700six4xi.py
ξ »zap2800six4xi.py
ξ »zap2900six4xi.py
ξ »zap3000six4xi.py
ξ »zap3100six4xi.py
ξ »zap3200six4xi.py
ξ »zap3300six4xi.py

ξ »zap0000seven4xi.py
ξ »zap0001seven4xi.py
ξ »zap0010seven4xi.py
ξ »zap0100seven4xi.py
ξ »zap0200seven4xi.py
ξ »zap0300seven4xi.py
ξ »zap0400seven4xi.py
ξ »zap0500seven4xi.py
ξ »zap0600seven4xi.py
ξ »zap0700seven4xi.py
ξ »zap0800seven4xi.py
ξ »zap0900seven4xi.py
ξ »zap1000seven4xi.py
ξ »zap1100seven4xi.py
ξ »zap1200seven4xi.py
ξ »zap1300seven4xi.py
ξ »zap1400seven4xi.py
ξ »zap1500seven4xi.py
ξ »zap1600seven4xi.py
ξ »zap1700seven4xi.py
ξ »zap1800seven4xi.py
ξ »zap1900seven4xi.py
ξ »zap2000seven4xi.py
ξ »zap2100seven4xi.py
ξ »zap2200seven4xi.py
ξ »zap2300seven4xi.py
ξ »zap2400seven4xi.py
ξ »zap2500seven4xi.py
ξ »zap2600seven4xi.py
ξ »zap2700seven4xi.py
ξ »zap2800seven4xi.py
ξ »zap2900seven4xi.py
ξ »zap3000seven4xi.py
ξ »zap3100seven4xi.py
ξ »zap3200seven4xi.py
ξ »zap3300seven4xi.py

ξ »zap0000eight4xi.py
ξ »zap0001eight4xi.py
ξ »zap0010eight4xi.py
ξ »zap0100eight4xi.py
ξ »zap0200eight4xi.py
ξ »zap0300eight4xi.py
ξ »zap0400eight4xi.py
ξ »zap0500eight4xi.py
ξ »zap0600eight4xi.py
ξ »zap0700eight4xi.py
ξ »zap0800eight4xi.py
ξ »zap0900eight4xi.py
ξ »zap1000eight4xi.py
ξ »zap1100eight4xi.py
ξ »zap1200eight4xi.py
ξ »zap1300eight4xi.py
ξ »zap1400eight4xi.py
ξ »zap1500eight4xi.py
ξ »zap1600eight4xi.py
ξ »zap1700eight4xi.py
ξ »zap1800eight4xi.py
ξ »zap1900eight4xi.py
ξ »zap0000eight4xi.py
ξ »zap0100eight4xi.py
ξ »zap0120eight4xi.py
ξ »zap0210eight4xi.py
ξ »zap0210eight4xi.py
ξ »zap0210eight4xi.py
ξ »zap0210eight4xi.py
ξ »zap0210eight4xi.py
ξ »zap0210eight4xi.py
ξ »zap0210eight4xi.py
ξ »zap3000eight4xi.py
ξ »zap3100eight4xi.py
ξ »zap3200eight4xi.py
ξ »zap3300eight4xi.py

ξ »zap2module4xi.py
ξ explored to use original function names (e.g. set_zskeleton4xi) in trace to access the source module (e.g zskeleton4xi.py)
ξ explored to use original method names with class (e.g. __init__-of-ZSkeleton4Xi) in trace to access the source module (e.g zskeleton4xi.py)
ξ synonyms exists until the corresponding object has been zapped and verified to give the right source module
ξ -of-Class must be updated for all methods in all modules!
ξ trace settings in ALL modules have to be updated after zap2module4xi.py has been updated!
ξ ALL modules have to be compiled and TESTED to test and to produce sense, reason and ace XML-files!
ξ ALL sense, reason and ace XML-files must be scoped!
ξ it might be wise to continue zapping only after above steps have been completed - or do one by one

ξ »zskeleton4xi.py
ξ upgraded trace message setting according to the above guidelines
ξ »test_zskeleton4xi.py
ξ run to produce one new xml-file!
ξ »actor4xi.py
ξ upgraded to depict in the method tag the class of the methods (e.g. __init__-of-ZSkeleton4Xi)
ξ »test_actor4xi.py
ξ »test_coordinate4xi.py
ξ »test_noun4xi.py
ξ run to produce one new scope file!

ξ »zap2actor4xi.py
ξ set trace for get from queues of level 10
ξ levels 100 ... 3300 must be implemented next for this module and
ξ it must check the level of a dictionary it gets before saving it into corresponding dictionary
ξ it will produce statistics about receive and get operations

ξ »zap0010one4xi.py
ξ »zap0010two4xi.py
ξ »zap0010three4xi.py
ξ »zap0010four4xi.py
ξ »zap0010five4xi.py
ξ »zap0010six4xi.py
ξ »zap0010seven4xi.py
ξ »zap0010eight4xi.py
ξ layer 10 handling tested!

December 14, 2010
ξ »zap2module4xi.py
ξ examined wheter methods of classes have to be defined
ξ errors revealed by linking modules to dragon-nodes corrected
ξ »import4xi.py
ξ »kskeleton
ξ »test_zap2actor4xi.py

ξ »zap2actor4xi.py
ξ layer 10 processing upgraded - getting from THREE failes ; gets 100 shots .i.e. synchronize error
ξ explored having one get loop which checks from which direction and level answer messages and queues come from

ξ »zap0000one4xi.py
ξ »zap0000two4xi.py
ξ »zap0000three4xi.py
ξ »zap0000four4xi.py
ξ »zap0000five4xi.py
ξ »zap0000six4xi.py
ξ »zap0000seven4xi.py
ξ »zap0000eight4xi.py
ξ layer 10 upgraded to directions 2 ... 8
ξ »zap0010one4xi.py
ξ »zap0010two4xi.py
ξ »zap0010three4xi.py
ξ »zap0010four4xi.py
ξ »zap0010five4xi.py
ξ »zap0010six4xi.py
ξ »zap0010seven4xi.py
ξ »zap0010eight4xi.py
ξ layer 10 handling upgraded - en empty dictionary might be returned from layer 10!

December 13, 2010
ξ »test_zap2actor4xi.py
ξ »zap2actor4xi.py
ξ »zap0000one4xi.py
ξ »zap0010one4xi.py
ξ »zap2module4xi.py
ξ programmed and tested solving module for actor

December 12, 2010
ξ »test_zap2actor4xi.py
ξ »zap2actor4xi.py
ξ »zap0000one4xi.py
ξ »zap0010one4xi.py
ξ tested embedded navigation links !
ξ the links of the first and last node to be solved by the main module zap2actor4xi.py, because those links must point to nodes at lower and higher layers!

December 11, 2010
ξ »zap0010one4xi.py
ξ programmed navigation links to nodes

December 10, 2010
ξ »zap0010one4xi.py
ξ upgraded to process dictionaries with constants
ξ started to build navigation tags

December 09, 2010
ξ »print4xi.py
ξ upgraded to handle Step-chraracters in trace which itself contains trace - such as test_zap2actor4xi.py trace !
ξ decided to implement layer 10 to all directions as the next step
ξ brainstormed that special oregon nodes such as (+0x+0y+0z) can be used to save layer knowledgebase
ξ decided to embed navigation to each node at a layer in threads and let main program to add navigation between layers!

December 08, 2010
ξ »test_zap2actor4xi.py
ξ »zap2actor4xi.py
ξ »zap0000one4xi.py
ξ »zap0010one4xi.py
ξ »print4xi.py
ξ »pickle2z4xi.py
ξ dragonized trace added and used to verify functionality - modules tested having only dragonized trace on
ξ »forkingpickler4xi.py
ξ method names modified for XML presentation - one can freely select method name, print4xi.py uses only class name for trace

December 07, 2010
ξ »test_zap2actor4xi.py
ξ »zap2actor4xi.py
ξ »zap0000one4xi.py
ξ »zap0000two4xi.py
ξ »zap0000three4xi.py
ξ »zap0000four4xi.py
ξ »zap0000five4xi.py
ξ »zap0000six4xi.py
ξ »zap0000seven4xi.py
ξ »zap0000eight4xi.py
ξ »zap0000one4xi.py
ξ »zap0001one4xi.py
ξ »zap0001two4xi.py
ξ »zap0001three4xi.py
ξ »zap0001four4xi.py
ξ »zap0001five4xi.py
ξ »zap0001six4xi.py
ξ »zap0001seven4xi.py
ξ »zap0001eight4xi.py
ξ layer 02 = skeleton zapped; dragonized trace combined with app trace useful!
ξ layer 20 zapped to direction one - when a lot of trace prints are being printed you might loose normal print message!

December 06, 2010
ξ »test_zap2actor4xi.py
ξ »zap2actor4xi.py
ξ »zap0000one4xi.py
ξ »zap0001one4xi.py
ξ programmed processing of skeleton (layer 02) to direction one - added Pipe4Xi to be traced and used dragonized trace to solve multiprocessing challenges

December 04, 2010
ξ added Zap-knowledgebase globals to all zap-modules; run verifications to zap-modules

December 03, 2010
ξ »find4txt.py
ξ mined zap-modules for verification; defined profile to walk trough either .txt or .py modules
ξ »parse4xi.py
ξ parsed all modules
ξ »zap2actor4xi.py
ξ »test_zap2actor4xi.py
ξ run command and control with new zap modules & passing (x,y,z) coordinates

December 02, 2010
ξ »zap0000one4xi.py
ξ »zap0001one4xi.py
ξ »zap0010one4xi.py
ξ »zap0100one4xi.py
ξ »zap0200one4xi.py
ξ »zap0300one4xi.py
ξ »zap0400one4xi.py
ξ »zap0500one4xi.py
ξ »zap0600one4xi.py
ξ »zap0700one4xi.py
ξ »zap0800one4xi.py
ξ »zap0900one4xi.py
ξ »zap1000one4xi.py
ξ »zap1100one4xi.py
ξ »zap1200one4xi.py
ξ »zap1300one4xi.py
ξ »zap1400one4xi.py
ξ »zap1500one4xi.py
ξ »zap1600one4xi.py
ξ »zap1700one4xi.py
ξ »zap1800one4xi.py
ξ »zap1900one4xi.py
ξ »zap2000one4xi.py
ξ »zap2100one4xi.py
ξ »zap2200one4xi.py
ξ »zap2300one4xi.py
ξ »zap2400one4xi.py
ξ »zap2500one4xi.py
ξ »zap2600one4xi.py
ξ »zap2700one4xi.py
ξ »zap2800one4xi.py
ξ »zap2900one4xi.py
ξ »zap3000one4xi.py
ξ »zap3100one4xi.py
ξ »zap3200one4xi.py
ξ »zap3300one4xi.py

ξ »zap0000two4xi.py
ξ »zap0001two4xi.py
ξ »zap0010two4xi.py
ξ »zap0100two4xi.py
ξ »zap0200two4xi.py
ξ »zap0300two4xi.py
ξ »zap0400two4xi.py
ξ »zap0500two4xi.py
ξ »zap0600two4xi.py
ξ »zap0700two4xi.py
ξ »zap0800two4xi.py
ξ »zap0900two4xi.py
ξ »zap1000two4xi.py
ξ »zap1100two4xi.py
ξ »zap12000two4xi.py
ξ »zap13000two4xi.py
ξ »zap14000two4xi.py
ξ »zap15000two4xi.py
ξ »zap16000two4xi.py
ξ »zap17000two4xi.py
ξ »zap18000two4xi.py
ξ »zap19000two4xi.py
ξ »zap2000two4xi.py
ξ »zap2100two4xi.py
ξ »zap2200two4xi.py
ξ »zap2300two4xi.py
ξ »zap2400two4xi.py
ξ »zap2500two4xi.py
ξ »zap2600two4xi.py
ξ »zap2700two4xi.py
ξ »zap2800two4xi.py
ξ »zap2900two4xi.py
ξ »zap3000two4xi.py
ξ »zap3100two4xi.py
ξ »zap3200two4xi.py
ξ »zap3300two4xi.py

ξ »zap0000three4xi.py
ξ »zap0001three4xi.py
ξ »zap0010three4xi.py
ξ »zap0100three4xi.py
ξ »zap0200three4xi.py
ξ »zap0300three4xi.py
ξ »zap0400three4xi.py
ξ »zap0500three4xi.py
ξ »zap0600three4xi.py
ξ »zap0700three4xi.py
ξ »zap0800three4xi.py
ξ »zap0900three4xi.py
ξ »zap1000three4xi.py
ξ »zap1100three4xi.py
ξ »zap1200three4xi.py
ξ »zap1300three4xi.py
ξ »zap1400three4xi.py
ξ »zap1500three4xi.py
ξ »zap1600three4xi.py
ξ »zap1700three4xi.py
ξ »zap1800three4xi.py
ξ »zap1900three4xi.py
ξ »zap2000three4xi.py
ξ »zap2100three4xi.py
ξ »zap2200three4xi.py
ξ »zap2300three4xi.py
ξ »zap2400three4xi.py
ξ »zap2500three4xi.py
ξ »zap2600three4xi.py
ξ »zap2700three4xi.py
ξ »zap2800three4xi.py
ξ »zap2900three4xi.py
ξ »zap3000three4xi.py
ξ »zap3100three4xi.py
ξ »zap3200three4xi.py
ξ »zap3300three4xi.py

ξ »zap0000four4xi.py
ξ »zap0001four4xi.py
ξ »zap0010four4xi.py
ξ »zap0100four4xi.py
ξ »zap0200four4xi.py
ξ »zap0300four4xi.py
ξ »zap0400four4xi.py
ξ »zap0500four4xi.py
ξ »zap0600four4xi.py
ξ »zap0700four4xi.py
ξ »zap0800four4xi.py
ξ »zap0900four4xi.py
ξ »zap01000four4xi.py
ξ »zap01100four4xi.py
ξ »zap1200four4xi.py
ξ »zap1300four4xi.py
ξ »zap1400four4xi.py
ξ »zap1500four4xi.py
ξ »zap1600four4xi.py
ξ »zap1700four4xi.py
ξ »zap1800four4xi.py
ξ »zap1900four4xi.py
ξ »zap2000four4xi.py
ξ »zap2100four4xi.py
ξ »zap2200four4xi.py
ξ »zap2300four4xi.py
ξ »zap2400four4xi.py
ξ »zap2500four4xi.py
ξ »zap2600four4xi.py
ξ »zap2700four4xi.py
ξ »zap2800four4xi.py
ξ »zap2900four4xi.py
ξ »zap3000four4xi.py
ξ »zap3100four4xi.py
ξ »zap3200four4xi.py
ξ »zap3300four4xi.py

ξ »zap0000five4xi.py
ξ »zap0001five4xi.py
ξ »zap0010five4xi.py
ξ »zap0100five4xi.py
ξ »zap0200five4xi.py
ξ »zap0300five4xi.py
ξ »zap0400five4xi.py
ξ »zap0500five4xi.py
ξ »zap0600five4xi.py
ξ »zap0700five4xi.py
ξ »zap0800five4xi.py
ξ »zap0900five4xi.py
ξ »zap1000five4xi.py
ξ »zap1100five4xi.py
ξ »zap1200five4xi.py
ξ »zap1300five4xi.py
ξ »zap1400five4xi.py
ξ »zap1500five4xi.py
ξ »zap1600five4xi.py
ξ »zap1700five4xi.py
ξ »zap1800five4xi.py
ξ »zap1900five4xi.py
ξ »zap2000five4xi.py
ξ »zap2100five4xi.py
ξ »zap2200five4xi.py
ξ »zap2300five4xi.py
ξ »zap2400five4xi.py
ξ »zap2500five4xi.py
ξ »zap2600five4xi.py
ξ »zap2700five4xi.py
ξ »zap2800five4xi.py
ξ »zap2900five4xi.py
ξ »zap3000five4xi.py
ξ »zap3100five4xi.py
ξ »zap3200five4xi.py
ξ »zap3300five4xi.py

ξ »zap0000six4xi.py
ξ »zap0001six4xi.py
ξ »zap0010six4xi.py
ξ »zap0100six4xi.py
ξ »zap0200six4xi.py
ξ »zap0300six4xi.py
ξ »zap0400six4xi.py
ξ »zap0500six4xi.py
ξ »zap0600six4xi.py
ξ »zap0700six4xi.py
ξ »zap0800six4xi.py
ξ »zap0900six4xi.py
ξ »zap1000six4xi.py
ξ »zap1100six4xi.py
ξ »zap1200six4xi.py
ξ »zap1300six4xi.py
ξ »zap1400six4xi.py
ξ »zap1500six4xi.py
ξ »zap1600six4xi.py
ξ »zap1700six4xi.py
ξ »zap1800six4xi.py
ξ »zap1900six4xi.py
ξ »zap2000six4xi.py
ξ »zap2100six4xi.py
ξ »zap2200six4xi.py
ξ »zap2300six4xi.py
ξ »zap2400six4xi.py
ξ »zap2500six4xi.py
ξ »zap2600six4xi.py
ξ »zap2700six4xi.py
ξ »zap2800six4xi.py
ξ »zap2900six4xi.py
ξ »zap3000six4xi.py
ξ »zap3100six4xi.py
ξ »zap3200six4xi.py
ξ »zap3300six4xi.py

ξ »zap0000seven4xi.py
ξ »zap0001seven4xi.py
ξ »zap0010seven4xi.py
ξ »zap0100seven4xi.py
ξ »zap0200seven4xi.py
ξ »zap0300seven4xi.py
ξ »zap0400seven4xi.py
ξ »zap0500seven4xi.py
ξ »zap0600seven4xi.py
ξ »zap0700seven4xi.py
ξ »zap0800seven4xi.py
ξ »zap0900seven4xi.py
ξ »zap1000seven4xi.py
ξ »zap1100seven4xi.py
ξ »zap1200seven4xi.py
ξ »zap1300seven4xi.py
ξ »zap1400seven4xi.py
ξ »zap1500seven4xi.py
ξ »zap1600seven4xi.py
ξ »zap1700seven4xi.py
ξ »zap1800seven4xi.py
ξ »zap1900seven4xi.py
ξ »zap2000seven4xi.py
ξ »zap2100seven4xi.py
ξ »zap2200seven4xi.py
ξ »zap2300seven4xi.py
ξ »zap2400seven4xi.py
ξ »zap2500seven4xi.py
ξ »zap2600seven4xi.py
ξ »zap2700seven4xi.py
ξ »zap2800seven4xi.py
ξ »zap2900seven4xi.py
ξ »zap3000seven4xi.py
ξ »zap3100seven4xi.py
ξ »zap3200seven4xi.py
ξ »zap3300seven4xi.py

ξ »zap0000eight4xi.py
ξ »zap0001eight4xi.py
ξ »zap0010eight4xi.py
ξ »zap0100eight4xi.py
ξ »zap0200eight4xi.py
ξ »zap0300eight4xi.py
ξ »zap0400eight4xi.py
ξ »zap0500eight4xi.py
ξ »zap0600eight4xi.py
ξ »zap0700eight4xi.py
ξ »zap0800eight4xi.py
ξ »zap0900eight4xi.py
ξ »zap1000eight4xi.py
ξ »zap1100eight4xi.py
ξ »zap1200eight4xi.py
ξ »zap1300eight4xi.py
ξ »zap1400eight4xi.py
ξ »zap1500eight4xi.py
ξ »zap1600eight4xi.py
ξ »zap1700eight4xi.py
ξ »zap1800eight4xi.py
ξ »zap1900eight4xi.py
ξ »zap0000eight4xi.py
ξ »zap0100eight4xi.py
ξ »zap0120eight4xi.py
ξ »zap0210eight4xi.py
ξ »zap0210eight4xi.py
ξ »zap0210eight4xi.py
ξ »zap0210eight4xi.py
ξ »zap0210eight4xi.py
ξ »zap0210eight4xi.py
ξ »zap0210eight4xi.py
ξ »zap3000eight4xi.py
ξ »zap3100eight4xi.py
ξ »zap3200eight4xi.py
ξ »zap3300eight4xi.py

ξ »find4txt.py
ξ upgraded to mine errors and warnings in larger files which are created by runs performing actions to several targets

November 30, 2010
ξ »zap2actor4xi.py
ξ established command & control with 8 charge-processes - each with 33 fire-threads !
ξ »test_zap2actor4xi.py
ξ zapped all scope-sense-files with more robust xml-modules - without memory error - memry up to 3.3 gigabytes during run!
ξ hit MemoryError in xml_trace_sense4xi.py line 339 for loop - added try-block to xml-modules for loop!
ξ »xml_trace_ace4xi.py
ξ »xml_trace_reason4xi.py
ξ »xml_trace_sense4xi.py
ξ added try-blocks and let pass in exceptions which might happen if improper xml-data is tried to saved by a calling program

November 29, 2010
ξ »fire2one4xi.py
ξ »fire2two4xi.py
ξ »fire2three4xi.py
ξ »fire2four4xi.py
ξ »fire2five4xi.py
ξ »fire2six4xi.py
ξ »fire2seven4xi.py
ξ »fire2eight4xi.py
ξ compiled with ack2build = True to build (x,y,z) for the required layers
ξ compiled with ack2sense = True to check (x,y,z) in all levels by calculating radius and deviation
ξ »fire3200one4xi.py
ξ »fire3200two4xi.py
ξ »fire3200three4xi.py
ξ »fire3200four4xi.py
ξ »fire3200five4xi.py
ξ »fire3200six4xi.py
ξ »fire3200seven4xi.py
ξ »fire3200eight4xi.py
ξ cluster coordinates as well as other coordinates verified with software and updated !
ξ »zap2actor4xi.py
ξ »test_zap2actor4xi.py
ξ »actor4xi.py
ξ »test_actor4xi.py
ξ »noun4xi.py
ξ »test_noun4xi.py
ξ »verb4xi.py
ξ »test_coordinate4xi.py
ξ create also clusters with no data for (x,y,z) skeleton to be zapped to layer 3200!
ξ »scope-ace-test-zskeleton4xi.xml
ξ »scope-reason-test-zskeleton4xi.xml
ξ »scope-sense-test-zskeleton4xi.xml
ξ cluster dragon coordinates are for super-cluster !!!
ξ ray and deviation are missing - they had revealed the bug !!!
ξ »zap2actor4xi.py

November 28, 2010
ξ in all the following modules with all directories removed index 0 and its processing!
ξ in all three modules fixed the problem with cluster and super statistics
ξ »actor4xi.py
ξ »test_actor4xi.py
ξ »noun4xi.py
ξ »test_noun4xi.py
ξ »verb4xi.py
ξ »test_coordinate4xi.py
ξ scoped all sense, reason and ace xml files !

November 27, 2010
ξ »zap2actor4xi.py
ξ set layer data for all nodes NOT trusting scoping phase data but the one on layer counters!
ξ changed origin direction to zero and layer to 1
ξ »actor4xi.py
ξ found problems with cluster and super statistics - seems to be double - check scope phase!

November 26, 2010
ξ »zap2actor4xi.py
ξ printed ZapKB and zeroed layer data
ξ programmed zap output path to use zap folder thereby keeping input xml-files in separate folder
ξ tuned trace messages; tested with ack2debug False; explored the next phase to update layer data in dictionary
ξ »test_zap2actor4xi.py
ξ examined the case where a super cluster direction has no elements - it might get set when the whole sphere is processed
ξ »find4txt.py
ξ »version4xi.py
ξ started FAILED search in temptokatera to make sure creation of actor, noun and verb xml-files are ok to be zapped
ξ interrupted - must be done in smaller steps by running one scoping at time and checking possible erros!

November 25, 2010
ξ »zap2actor4xi.py
ξ »test_zap2actor4xi.py
ξ processed clusters and super-clusters with one file!
ξ »actor4xi.py
ξ »noun4xi.py
ξ »verb4xi.py
ξ upgraded cluster and super-cluster processing!
ξ »test_actor4xi.py
ξ »test_noun4xi.py
ξ »test_coordinate4xi.py
ξ updated all xml-files !

November 23, 2010
ξ »zap2actor4xi.py
ξ »test_zap2actor4xi.py
ξ explored skenarios with cluster and super-cluster a) to skip b) to build c) to leave to 8 processes to be activate
ξ explored skenarios with layer a) to skip b) to build c) to leave to 8 processes to be activate
ξ changed definition to identity and made it look the same for skeleton and origin as it is for normal nodes
ξ upgraded messages for origin and skeleton to be compatible of those for normal nodes
ξ differentiated function and method - created actor-attribute and profile-attribute 1='function' or 2='method'
ξ omitted waves-attribute because key allows to add new attribute anyway

November 22, 2010
ξ »zap2actor4xi.py
ξ »test_zap2actor4xi.py
ξ zapped the first file - cluster and super-cluster to be processed!

November 19, 2010
ξ »zap2actor4xi.py
ξ started to process normal nodes
ξ succeeded to process new origin and skeleton structures
ξ hit by the case where print4xi.py did NOT print the right value although parameter was ok - unresolved dangerous exception:
ξ message2print = "{(STEP 11S2fc/33) accepted" + "; deviation2xi-accepted-by-zap2actor4xi: " + str(deviation2xi) + "; time: " + time4xi() + "}"
ξ print4xi(class2print, method2print, message2print) # 29 <-- ??? 39.0 once although 29 was given in parameter!

November 18, 2010
ξ »zap2actor4xi.py
ξ hit by Python feature: programmed if ak2debug is True instead of if ack2debug is True and compiler did NOT warn about undefined variable!

November 17, 2010
ξ »zap2actor4xi.py
ξ redefines Zap Knowledgebase based on the latest news about 3D-holographics displays and decided to define (x,y,z) as primary key and to add data to each node!
ξ »test_zap2actor4xi.py
ξ created origin-node and 8 skeletons nodes with new structure

November 16, 2010
ξ »zap2actor4xi.py
ξ programmed processing of eight (8) skeletons, upgraded skeleton colors; corrected ZapKB4Xi to point to the right Zap knowledgebase

November 15, 2010
ξ »print4xi.py
ξ changed 'NACK4XI' to all to prevent debug print during compilation phase!
ξ origin handled
ξ »test_zap2actor4xi.py
ξ upgraded set_trace4xi function so that it reads trace permission from pickle2?4xi.py files, which are set to ACK4Xi to prevent trace
ξ added normal print-commands to get rid off trivial bugs fast - fexibility allowed & you can either leave or comment thos lines - TIP!
ξ print4xi.py saves objects into knowledgebase to be files to XML-format and XML does NOT accepts some characters - TIP!

November 11, 2010
ξ »print4xi.py
ξ changed to handle NACK4XI instead of False because of settings in all pickle files!
ξ hit serious challenge with programs calling print4xi in modular level for example to define classes based on OS!
ξ when a module such as import4xi import class such as Heap4Xi, then Heap4Xi gets executed when import4xi.py is compiled!
ξ »popen4xi.py
ξ »arena4xi.py
ξ you can NOT change these programs because that would mean new tests !
ξ »test_print4xi.py
ξ tuned tracing - which is special - in the module using directly print-function to trace itself, if required!
ξ run comprehensive tests - after all this THE critical module in the system!
ξ »hello_world4xi.py
ξ NACK4XI in setting trace - other porgrams have to be upgraded too!
ξ »pickle2a4xi.py
ξ NACK4XI = not tested .i. TRACE IT
ξ »test_zskeleton4xi.py
ξ challeges!
ξ »test_constant_heap4xi.py
ξ »sense-test-constant-heap4xi.xml
ξ »reason-test-constant-heap4xi.xml
ξ »ace-test-constant-heap4xi.xml
ξ to verify - worked before !

November 10, 2010
ξ »zap2actor4xi.py
ξ explored the idea of moving Zap1KB4Xi ... Zap2KB4Xi into modules and building sense, reason and ace for disctionaries
ξ »fire10one4xi.py
ξ calculates statistics from its dictionary for verification!
ξ decided to build cluster and super-cluster data from XML-input instead of using provided statistics in input!
ξ decided to import cluster and super-cluster dictionaries only in zap-programs!

November 9, 2010
ξ »zap2actor4xi.py
ξ upgraded tag-searching pattern for program itself and for parser4xi.py
ξ added verbs such as fail to tag programs for tracing (code even looked better) »TIPS
ξ updated »[001] Benefits of Dragonized Multi-Core System

November 8, 2010
ξ »zap2actor4xi.py
ξ creating the first prototype to read input-xml and to built zap-directories give to 8 subprocesses
ξ defined skeleton node for each direction
ξ initialized origin for each layer and for each node
ξ defined zap knowledgebase ZapKB4Xi for eight(8) directions with layers 2, 10, 100, 200 ... 3100, 3200, 3300
ξ implementing dragon trace
ξ »print4xi.py ξ »pickle2z4xi.py ξ »pickle2c4xi.py ξ »pickle2a4xi.py ξ »pickle2r4xi.py ξ »pickle2s4xi.py

November 5, 2010
ξ »test_coordinate4xi.py
ξ »verb4xi.py
ξ »[029] Scoped Reason XML-files

November 4, 2010
ξ »fire3300one4xi.py statistics »fire3300one4xi.txt
ξ 3300 one statistics:
ξ layer2fire: 3300; count2xyz: 119; deviation2expected: 19; max2deviation: 99
ξ average2radius: 3300; max2radius: 3399; std2deviation: 9; std2varians: 84; degree2freedom: 118

ξ »fire100one4xi.py statistics »fire100one4xi.txt
ξ »fire10one4xi.py statistics »fire10one4xi.txt
ξ »shoot10one4xi.py
ξ standard deviation = 9 <=> coordinated casted ok
ξ maximum deviation = 99 <=> coordinates between layer x and layer x+1 mapped to lower layer x

ξ »test_sphere4xi.py
ξ analyzed possibility to abondon integers and to use more accurate coordinates
ξ »test_actor4xi.py
ξ »actor4xi.py
ξ tuned warning and exception messages adding more information and ** to depict warning
ξ upgraded skeleton (x,y,z) data with ray and deviation
ξ tested ack2debug = False to be able to view only possible errors and warnings
ξ treated cluster and super-cluster-statistics as information and added verification for super-cluster total against cluster total

November 3, 2010
ξ »test_actor4xi.py
ξ »actor4xi.py
ξ added deviation and ray for scoped coordinates - not to clusters and super-clusters, which are simulated and correct
ξ (x,y,z)-coordinates casted to lower layer: distance4xi = 400; ray = 498.875736031; deviation = 98
ξ distance 10 ... 99 into use: distance = 10, ray = 49.6588360717; deviation = 39
ξ analyzed changing (x,y,z)-integers to floats and thereby generating more (x,y,z)-coordinates

November 2, 2010
ξ »test_zap2actor4xi.py
ξ »zap2actor4xi.py
ξ »scope-sense-test-zskeleton4xi.xml
ξ »scope-sense-hello-world4xi.xml
ξ decided to add deviation and ray for scoped coordinates

November 1, 2010
ξ »test_zap2actor4xi.py
ξ »zap2actor4xi.py
ξ started zapping actors
ξ »test_zap2verb4xi.py
ξ »zap2verb4xi.py
ξ started zapping verbs
ξ »test_zap2noun4xi.py
ξ »zap2noun4xi.py
ξ started zapping nouns

October 30, 2010
ξ »parse4xi.py
ξ parsed multiprocessing source programs
ξ »Multiprocessing4Xi - Release 4.19
ξ updated HTML documentation

October 29, 2010
ξ »test_actor4xi.py
ξ »actor4xi.py
ξ added method, function and message to (x,y,z)-node information »(029) Scoped sense-, ace- and reason-XML-files

October 28, 2010
ξ »test_actor4xi.py
ξ »actor4xi.py
ξ »actor2a4xi.py
ξ »actor2b4xi.py
ξ »actor2c4xi.py
ξ »actor2d4xi.py
ξ »actor2e4xi.py
ξ »actor2f4xi.py
ξ »actor2g4xi.py
ξ »actor2h4xi.py
ξ »actor2i4xi.py
ξ »actor2j4xi.py
ξ »actor2k4xi.py
ξ »actor2l4xi.py
ξ »actor2m4xi.py
ξ »actor2n4xi.py
ξ »actor2o4xi.py
ξ »actor2p4xi.py
ξ »actor2q4xi.py
ξ »actor2r4xi.py
ξ »actor2s4xi.py
ξ »actor2t4xi.py
ξ »actor2u4xi.py
ξ »actor2v4xi.py
ξ »actor2w4xi.py
ξ »actor2x4xi.py
ξ »actor2y4xi.py
ξ »actor2z4xi.py
ξ »actor2_4xi.py
ξ actors with attributes such as color and cluster
ξ »test_noun4xi.py
ξ »noun4xi.py
ξ defined colors to all clusters
ξ »(029) Scoped sense-, ace- and reason-XML-files

October 27, 2010
ξ »test_noun4xi.py
ξ »noun4xi.py
ξ scoped all ace files »(029) Scoped ace- and reason-XML-files

October 26, 2010
ξ »test_noun4xi.py
ξ »noun4xi.py
ξ »scope-ace-test-zskeleton4xi.xml
ξ created the first scope-ace file !
ξ challenges with some nouns using verbs such as started (no -by-) or take-into-account

October 25, 2010
ξ »noun4xi.py
ξ nouns handling of ace-files
ξ »noun2cluster4xi.py
ξ helps to set cluster to noun
ξ »verb4xi.py
ξ changed existing scope-file names to scope-reason-files to differentiate from scope-ace-file names

ξ »test_coordinate4xi.py
ξ scoped all reason files »(029) Reason and Scope XML-files

ξ explored HTML5 & multitasking & Python scripting

October 22, 2010
ξ »parsestudio4xi.py
ξ »parse4xi.py
ξ »version4xi.py

ξ »find4xi.py
ξ »find4txt.py
ξ »find4share.py
ξ »find4py.py
ξ »find4process.py
ξ »find4popen.py
ξ »find4binary.py
ξ version knowledgebase is defined in one module and others use it instead of having version information hard coded
ξ tested with Python 3.3 version in laptop

October 21, 2010
ξ decided to parse tag attributes, the number of which varies between different tags from None to five (5) in this version
ξ brainstormed next steps in parsing
ξ would it be wise to parse and let parser to create actor knowledge base from source files trusting on/checking tags such as function4xi ?
ξ an actor can be a) functions b) methods c) class objects
ξ actor name is a valid XML-name i.e. it does NOT have underscores unlike actors itself such as functions and methods !
ξ to prevent developers to create trace messages with wrong actors macros are being used
ξ parser must concentrate only into tags - not to read trace messages at all!
ξ object, DFD and state information is also available - how to use ?
ξ run all tests to make sure that parsing and editing programs did not create any problems into the system

October 16, 2010
ξ »parsestudio4xi.py
ξ programmed to parse Studio4Xi software - handles parsing itself, which contains dragonized tags!
ξ ============================================================================================================================================
ξ (STEP 33A/33) PARSED TOTALLY 36 TAGS IN : 30 MODULES 00:38:44 10/16/10 Pacific Daylight Time
ξ (STEP 33B/33) + OK PARSING ..//..//..//..//studio4xi//python//3.3//src// MODULES 00:38:44 10/16/10 Pacific Daylight Time
ξ (STEP 33C/33) + OK EXPLORING FOLDER ..//..//..//..//studio4xi//python//3.3//src// 00:38:44 10/16/10 Pacific Daylight Time
ξ ============================================================================================================================================

October 15, 2010
ξ »parse4xi.py
ξ defined profile dictionary in detail - brainstormed how to use in parsing keeping it simple although smart!

October 14, 2010
ξ »parse4xi.py
ξ added parser level intelligence such as checking end-tags succeeding to find end tags suchs as # missing in some modules
ξ »parse4xi.txt
ξ ============================================================================================================================================
ξ (STEP 33A/33) PARSED TOTALLY 36 TAGS IN : 718 MODULES 11:41:49 10/14/10 Pacific Daylight Time
ξ (STEP 33B/33) + OK PARSING ..//..//..//..//Sw4Xi//Python33//Lib//multiprocessing4xi// MODULES 11:41:49 10/14/10 Pacific Daylight Time
ξ (STEP 33C/33) + OK EXPLORING FOLDER ..//..//..//..//Sw4Xi//Python33//Lib//multiprocessing4xi// 11:41:49 10/14/10 Pacific Daylight Time
ξ ============================================================================================================================================

October 13, 2010
ξ »parse4xi.py
ξ programmed synonym handling
ξ successfully parsed all dragonized *4xi.py modules checking that all mandatory tags are being used in modules

October 12, 2010
ξ »parse4xi.py
ξ iced development in /lib/multiprocessing4xi folfer and moved to program in /studio4xi/python/3.3/src folder
ξ started to program parser in Studio4Xi and generated first parsing to all modules
ξ »parse4xi.txt

October 11, 2010
ξ »actor2a4xi.py
ξ »actor2b4xi.py
ξ »actor2c4xi.py
ξ »actor2d4xi.py
ξ »actor2e4xi.py
ξ »actor2f4xi.py
ξ »actor2g4xi.py
ξ »actor2h4xi.py
ξ »actor2i4xi.py
ξ »actor2j4xi.py
ξ »actor2k4xi.py
ξ »actor2l4xi.py
ξ »actor2m4xi.py
ξ »actor2n4xi.py
ξ »actor2o4xi.py
ξ »actor2p4xi.py
ξ »actor2q4xi.py
ξ »actor2r4xi.py
ξ »actor2s4xi.py
ξ »actor2t4xi.py
ξ »actor2u4xi.py
ξ »actor2v4xi.py
ξ »actor2w4xi.py
ξ »actor2x4xi.py
ξ »actor2y4xi.py
ξ »actor2z4xi.py
ξ »actor2_4xi.py
ξ created stubs to see structure and content - needed to be generated by software, if actor knowledgebase is built!

October 09, 2010
ξ »object4xi.py
ξ processes objects found in ace-xml files and produces impose xml-files for scoping
ξ »test_object4xi.py
ξ tests objects
ξ »object2a4xi.py
ξ »object2b4xi.py
ξ »object2c4xi.py
ξ »object2d4xi.py
ξ »object2e4xi.py
ξ »object2f4xi.py
ξ »object2g4xi.py
ξ »object2h4xi.py
ξ »object2i4xi.py
ξ »object2j4xi.py
ξ »object2k4xi.py
ξ »object2l4xi.py
ξ »object2m4xi.py
ξ »object2n4xi.py
ξ »object2o4xi.py
ξ »object2p4xi.py
ξ »object2q4xi.py
ξ »object2r4xi.py
ξ »object2s4xi.py
ξ »object2t4xi.py
ξ »object2u4xi.py
ξ »object2v4xi.py
ξ »object2w4xi.py
ξ »object2x4xi.py
ξ »object2y4xi.py
ξ »object2z4xi.py
ξ »object2_4xi.py
ξ skeletons for object modules - Studio4Xi considered to help in creating these modules

ξ Note: actors - the one who perform - will need their own modules!

October 08, 2010
ξ »test_coordinate4xi.py
ξ scoped all reason files »(029) Reason and Scope XML-files
ξ »verb4xi.py
ξ updated cast2tense4xi function to return layer and applied it to verbs, clusters and super-clusters
ξ added approbriate verb attributes to cluster and superclusters

October 07, 2010
ξ »scope-verb4xi.xml
ξ [ack] clusterize all tenses of verb.
ξ [ack] color all tenses of verb.
ξ [ack] coordinate each verb tense to (x,y,z).
ξ [ack] define the verb with tense 1.
ξ [ack] direct each verb tense.
ξ [nack] distance each verb tense to a layer.
ξ [ack] fire each verb tense with an order number.
ξ [ack] refer with verb tense 2.
ξ [ack] symbolize the verb tense 3.
ξ [ack] have tense 1,2,3 and 4 to each verb (if different).

ξ »verb4xi.py
ξ added new attributes to skeleton and removed some rdfs-attributes
ξ abondoned the idea to use rdfs:domain for reference and decided to use the existing verb refer and own tag refer4xi
ξ added cluster 22=grapgics for symbolize verb to be used for symbolize4xi-tag
ξ »test_coordinate4xi.py
ξ skeleton distance4xi value changed to 2
ξ »verb2s4xi
ξ skeleton verb added; symbolize verb added; changed skip verb to cluster 7=tuning (was in cluster 6=problem)
ξ »verb2z4xi
ξ changed negative references in all verb modules to positive ones; they will be access keys and must be positive

October 06, 2010

ξ »verb4xi.py
ξ tuned cluster and supercluster statistics
ξ upgraded to handle (x,y,z) overflow by reusing indexes and by warning user who then can redesign clusters and superclusters
ξ »Super Clusters of Verbs
ξ »Clusters of Verbs
ξ »test_coordinate4xi.py
ξ »scope-reason-hello-world4xi.xml
ξ »scope-verb4xi.xml
ξ »scope-reason-test-skeleton-print4xi.xml

October 05, 2010
ξ changing clusterin and superclustering of verbs would distribute verbs more evenly to (x,y,z) 3D space
ξ in case of direction overflow, the system can provide 3D coordinates by keeping two of (x,y,z) zero / 1 /-1 ...
ξ basic/free version could provide only limited amount of (x,y,z) coordinates !

ξ »verb4xi.py
ξ with bigger reason files creating (x,y,z) fails - 120 (x,y,z) coordinates per vector might be too small ?
ξ if (task2cast['order'] > 3000) <-- (STEP 3z19b/33) PASSED WITH ORDER: 7575
ξ abondened the idea to split verb4xi.py into several modules - importing would loop!
ξ added distance4xi-tag and direct4xi-tag to core defining unit (x,y,z) to all eight(8) directions
ξ »reason-hello-world4xi.xml
ξ (STEP 13I/33) OF COORDINATE_TENSES4XI - ORDER2XI: 7575 <-- the first problem in scoping
ξ »sense-hello-world4xi.xml
ξ 7651 is the max ordernumber sensed, which seemed to be too high for verb4xi.py!
ξ »scope-reason-hello-world4xi.xml

ξ »scope-verb4xi.xml
ξ »scope-reason-test-skeleton-print4xi.xml
ξ + color4xi; direct4xi; fire4xi, and define4xi -tags added - some rdfs: tags replaced
ξ + ok i.e. not too many (x,y,z) coordinated to be generated !

ξ »verb2d4xi.py
ξ added direct verb

ξ »test_coordinate4xi.py
ξ tested individually scoping reason-files and searching erros in test_coordinate4xi.txt file
ξ »verb2w4xi.py
ξ »verb2f4xi.py
ξ »verb2s4xi.py
ξ »cluster2f4xi.py
ξ »cluster2s4xi.py

October 04, 2010
ξ created »025, »027, »029
ξ run all tests using keyboard profiles to create new xml-files for scoping
ξ »test_coordinate4xi.py
ξ upgraded to create scope file from all of those reason-xml files marked with nack
ξ updated M3 of Module Tester Profile G2 to t test_coordinate4xi - output is not directed to text file (it would become too large)
ξ checked new scoped files »029

ξ added for scoping verbs: 1) distance 2) super 3) coordinate 4) color 5) time 6) impose 7) define 8) cast 9) fire
ξ »test_coordinate4xi.py
ξ »reason-verb4xi.xml
ξ »scope-verb4xi.xml
ξ »test_skeleton_print4xi.py
ξ »scope-reason-test-skeleton-print4xi.xml

ξ updated »023

October 03, 2010
ξ »scope-verb4xi.xml
ξ scoped all available verbs with simulated order numbers to produce (x,y,z) coordinates - produced by coordinate_tenses4xi-function of verb4xi.py !
ξ »test_coordinate4xi.py
ξ »scope-reason-hello-world4xi.xml
ξ scoped normal reason-xml-file produced by a test - still works

October 02, 2010
ξ created Adding Verbs such as scope, cluster »VERBS AND SCOPING
ξ »verb2s4xi.py
ξ scope-verb added
ξ »verb2c4xi.py
ξ cluster-verb added
ξ »verb4xi
ξ ClusterColor4Xi dictionary updated due to scope and cluster verbs
ξ »cluster2s4xi.py
ξ #'scope': 21, 'scoped': 21, 'scoping': 21, #
ξ #'cluster': 21, 'clustered': 21, 'clustering': 21, #
ξ »skeleton_print4xi.py
ξ added scope, cluster both into function and class messages
ξ run G1=SkeletonPrint (or in command mode: t test_skeleton_print4xi > ..\txt\test_skeleton_print4xi.txt)
ξ »reason-test-skeleton-print4xi.xml
ξ found all scope tenses twice; both for function and for class messages
ξ go2studio in command mode and selected Assistant of Studio profile and run G2 = Macro created (or in command mode run macro4xi > ..\txt\macro4xi.txt)
ξ checked that all macros were created for all its tenses
ξ »scope-c
ξ »scoped-c
ξ »scoping-c
ξ »scope-f
ξ »scoped-f
ξ »scoping-f
ξ selected ProgramDeveloper4Xi profile
ξ picked an Unassigned key - G18 was picked for scope-c.txt macro-file just as an example to be used to add this skeleton to a program
ξ »scope-c
ξ selected Utility Tester profile
ξ in M1 run G4 = Verbs (or in command mode run: t test_verbkb4xi >..\txt\test_verbkb4xi.txt)
ξ »reason-verb4xi.xml
ξ this test also verified compilation of verb modules - you can perform this step 12 also earlier, for example before Step 5
ξ found scope, scoped and scoping tenses
ξ selected Module Tester
ξ run G2=Test Coordinate4xi (or in command mode run: t test_coordinate4xi >..\txt\test_coordinate4xi.txt
ξ »scope-reason-test-skeleton-print4xi.xml
ξ found scheme tenses - each twice
ξ in Notepad editor opened cluster4xi.txt in \Studio4Xi\c4xi\profile\developer4xi\program4xi folder
ξ saved it as scope4xi.txt
ξ »scope4xi
ξ selected ProgramDeveloper
ξ in Logitech G11 picked G18 Unassigned and created scope4xi with 8ms delay between characters
ξ opened a new file in editor and tested G18-key
ξ »scope4xi
ξ finding out which program writes reason-verb4xi.xml
ξ edit find4py.py
ξ »find4py.py
ξ select Assistant of Studio
ξ run G5= Find in Python source (or in command mode run: find4py > ..\txt\find4py.txt)
ξ searched text reason-verb4xi.xml in find4py.txt
ξ »find4py.txt
ξ function updating found to be xml_verb4xi
ξ »test_verbkb4xi.py
ξ test_verbkb4xi.py is the one: v2xi.xml_verb() #TEST_VERBKB4XI: XML BY CLASS CREATED XML FILE REASON-VERB4XI.XML
ξ reason_verb4xi-function of verb4xi.py had the bug: it treated verb attributes such as color as a tense!
ξ »verb4xi.py
ξ fixed function reason_verb4xi so that it prints only verb tenses as available verbs - not any verb attributes!
ξ »test_coordinate4xi.py
ξ »reason-verb4xi.xml
ξ available verbs xml as input to test_coordinate4xi.py
ξ run Module tester M3 Test Coordinate4xi (t test_coordinate4xi >..\txt\test_coordinate4xi.txt)
ξ »scope-verb4xi.xml
ξ scoped available verbs in the system - color which is rdfs range attribute!
ξ this might be due to the fact that this is NOT a normal reasoned file from a test but instead created from verb knowledgebase!
ξ »scope-reason-hello-world4xi.xml
ξ scoped reason-hello-world4xi.xml to make sure normally reasoned xml-files work

September 29, 2010
ξ »test_coordinate4xi
ξ continued tests with reason-xml files using also desktop folders for shortcuts - not only keyboard macros

September 28, 2010
ξ »test_coordinate4xi
ξ tested with several reason-xml-files by running the corresponding test first to make sure the latest reason-xml-file is being used

September 27, 2010
ξ »test_coordinate4xi
ξ programmed to create scope XML-files from reasoned XML-files
ξ »scope-reason-hello-world4xi.xml
ξ »verb4xi
ξ updated; only tense 1 can contain definition for a verb - not any of other tenses

September 23, 2010
ξ »verb4xi
ξ »scope-reason-test-skeleton-print4xi.xml
ξ »test_verbkb4xi.txt
ξ all verb tenses done - as well as embedded cluster and supercluster statistics

September 22, 2010
ξ »verb4xi
ξ upgraded function cast2tense4xi and succeed to build (x,y,z)-coordinates for verbs tense 1
ξ »scope-reason-test-skeleton-print4xi.xml

September 21, 2010
ξ »verb4xi
ξ programmed new function cast2tense4xi to cast (x,y,z)-coordinate to verb-tense
ξ updated cluster and super-cluster data for verbs to get all 1...8 directions for coordinates

September 20, 2010
ξ E:\Sw4Xi\Python31\xml\reason-test-skeleton-print4xi.xml <-- input file
ξ E:\Sw4Xi\Python31\xml\reason-verb4xi.xml <-- output file of test_verbkb4xi.py run (and the good reason to have normal print calls for debugging !)
ξ (STEP 15a/33) - CREATE (X,Y,Z) FOR TENSE 1 - LAYER DEPENDS ON ORDER(=TIME) - DIRECTION(1...8) DEPENDS ON SUPER-CLUSTER
ξ above is the point to continue and to set (x,y,z) to each verb-tense
ξ statistics to be looked in test_verbkb4xi.txt file:
ξ (STEP 19F/33) OF COORDINATE_TENSES4XI - TOTAL CLUSTER
ξ ======================================================================
ξ (STEP 19E/33) OF COORDINATE_TENSES4XI - CLUSTERCOLORSTATISTICS4XI:
ξ operations 310
ξ challenges 15
ξ network 102
ξ arithmetics 72
ξ events 18
ξ problems 40
ξ tuning 24
ξ acing 26
ξ manoeuvring 42
ξ administration 162
ξ sensing 20
ξ activity 26
ξ logical 30
ξ force 104
ξ messaging 16
ξ queuing 0
ξ birth 9
ξ activation 4
ξ documentation 45
ξ dataflow 27
ξ ======================================================================
ξ (STEP 19F/33) OF COORDINATE_TENSES4XI - TOTAL CLUSTER: 1092
ξ ======================================================================
ξ (STEP 19g/33) OF COORDINATE_TENSES4XI - SUPERCLUSTERCOLORSTATISTICS4XI:
ξ theater : 0
ξ network : 122
ξ manoeuvres : 51
ξ operations : 556
ξ successes : 74
ξ challenges : 15
ξ problems : 40
ξ miscellaneous : 234
ξ ======================================================================
ξ (STEP 19i/33) OF COORDINATE_TENSES4XI - TOTAL SUPER: 1092
ξ ======================================================================

ξ symbol number of verb = Webster Encyclopedic Unabridged Dictionary page number <=> max 2214 <=> symbols more difficult to develop
ξ cluster number 1 ... 33 <=> symbols can be developed easily
ξ super-cluster number 1 ...8 <=> symbols can be developed easily
ξ »test_verbkb4xi
ξ (1) v2xi = Verb4Xi()
ξ (2) v2xi.coordinate_tenses('..//..//xml//reason-test-skeleton-print4xi.xml')
ξ »verb4xixi
ξ (3) return coordinate_tenses4xi(file) <-- coordinate_tenses method of Verb4Xi-class calls function coordinate_tenses4xi
ξ (4) coordinate_tenses4xi(reason_file) <-- this is the function used, which then calls color_tenses4xi-function
ξ color_tenses4xi <-- this is THE one creating (x,y,z) coordinates to eight (8) directions into RAM fire-directories
ξ # print('(STEP 12b/33) OF COORDINATE_TENSES4XI - KEYS2ALPHA: ', keys2alpha) # dict_keys(['_', 'a', 'c', 'b', 'e', 'd', 'g', 'f', 'i', 'h', 'k', 'j', 'm', 'l', 'o', 'n', 'q', 'p', 's', 'r', 'u', 't', 'w', 'v', 'y', 'x', 'z'])
ξ (5) Colors2Verbs = color_tenses4xi() <-- coordinate_tenses4xi of verb4xi.py module calls function color_tenses4xi
ξ reason for above

September 7, 2010
ξ programmed direction EIGHT (X - ,Y - ,Z - )
ξ »test_verbkb4xi
ξ test passed OK i.e no FAILED-messages - no ** WARNING-messages neither any ** YIELDED-messages
ξ on console the message: Exception TypeError: NoneType object is not callable in finalize4xi - ignored
ξ »test_verbkb4xi.txt
ξ »charge2eight4xi
ξ OK all 33 threads
ξ »fire10eight4xi.py
ξ OK named pipe and queue with the right (x,y,z)-coordinate dictionary to the right queue with ok ack to named pipe
ξ »fire3300eight4xi.py

September 6, 2010
ξ programmed direction SEVEN (X - ,Y - ,Z + )
ξ »test_verbkb4xi
ξ test passed OK i.e no FAILED-messages - no ** WARNING-messages neither any ** YIELDED-messages
ξ on console the message: Exception TypeError: NoneType object is not callable in finalize4xi - ignored
ξ »test_verbkb4xi.txt
ξ »charge2seven4xi
ξ OK all 33 threads
ξ »fire10seven4xi.py
ξ OK named pipe and queue with the right (x,y,z)-coordinate dictionary to the right queue with ok ack to named pipe
ξ »fire3300seven4xi.py

September 3, 2010
ξ programmed direction SIX (X - ,Y + ,Z - )
ξ »test_verbkb4xi
ξ test passed OK i.e no FAILED-messages - no ** WARNING-messages neither any ** YIELDED-messages
ξ on console the message: Exception TypeError: NoneType object is not callable in finalize4xi - ignored
ξ »charge2six4xi
ξ OK all 33 threads
ξ »fire10six4xi.py
ξ OK named pipe and queue with the right (x,y,z)-coordinate dictionary to the right queue with ok ack to named pipe
ξ »fire3300six4xi.py

September 2, 2010
ξ updated and tested instructions how to create modules for a new coordinate direction
ξ »019

ξ programmed direction FIVE (X - ,Y + ,Z + )
ξ »test_verbkb4xi
ξ test passed OK i.e no FAILED-messages - no ** WARNING-messages neither any ** YIELDED-messages
ξ on console the message: Exception TypeError: NoneType object is not callable in finalize4xi - ignored
ξ »charge2five4xi
ξ OK all 33 threads
ξ »fire10five4xi.py
ξ OK named pipe and queue with the right (x,y,z)-coordinate dictionary to the right queue with ok ack to named pipe
ξ »fire3300five4xi.py

September 1, 2010
ξ created instructions how to create modules for a new coordinate direction
ξ »019

ξ programmed direction FOUR (X + ,Y - ,Z + )
ξ »test_verbkb4xi
ξ test passed OK i.e no FAILED-messages - no ** WARNING-messages neither any ** YIELDED-messages
ξ on console the message: Exception TypeError: NoneType object is not callable in finalize4xi - ignored
ξ »fire100four4xi.py
ξ puts the right dictionary .i.e. queue2four.put(shot2four1004xi) - note that modules give warning even if ack2debug is False

ξ »verb4xi
ξ FOUR-direction OK
ξ »fire10four4xi
ξ »fire3300four4xi
ξ did not have to put twice the dictionary 3300 !
ξ »charge2four4xi
ξ got the dictionary fire3300four4xi.py in the first time with four directions - was not the last one action

August 31, 2010
ξ programmed and tested direction THREE (X + ,Y + ,Z - )
ξ »test_verbkb4xi
ξ if FAILED messages then run test again - check also YIELDED messages
ξ »verb4xi
ξ verifies wheter queue get is None in which case it sets its own RAM directory to result
ξ »fire10three4xi
ξ »fire3300three4xi
ξ puts twice the dictionary !
ξ »charge2three4xi
ξ gets the dictionary only if fire3300three4xi.py puts it twice - otherwise gets None!

August 30, 2010
ξ programmed and tested direction TWO (X + ,Y - ,Z - )
ξ »test_verbkb4xi
ξ »verb4xi
ξ »fire10two4xi ...3300
ξ »charge2two4xi

August 27, 2010
ξ updated ack2debug setting and testing - debugging messages can be easily swicthed of/off in each module (note that print4xi is not used because it would produce XML-file)
ξ »test_verbkb4xi
ξ »verb4xi
ξ »fire10one4xi
ξ »charge2one4xi
ξ »cluster2b4xi.py
ξ added tense4 born

August 26, 2010
ξ programmed and tested direction ONE (X + ,Y + ,Z + )
ξ »test_verbkb4xi
ξ »verb4xi
ξ got via queue2one all 33 layers of direction one (x,y,z)- coordinates from activated 33 threads of process one for direction one
ξ measured performance - other 7 directions must be usable to get better measurements
ξ analyzed whether it would be wise to keep shot dictionaries and fire dictionarys separate or to replace each shot with fire dictionary got from queue
ξ verified output of fire threads/modules in verb4xi:
ξ »test_verbkb4xi.txt
ξ »fire10one4xi
...
ξ »fire3300one4xi

August 25, 2010
ξ »test_verbkb4xi
ξ optimized performance by handling queues and pipes for processes and threads optimally
ξ »verb4xi
ξ succeeded to receive ack via named pipe from all 33 threads about put operation to queue
ξ improved communication with fire*one4xi modules
ξ analyzed whether dummy processes should first be created and after that started instead of creating and starting one after another

August 24, 2010
ξ »charge2one4xi
ξ updated to activate 33 threads to direction one using the below target functions for DummuProcess4Xi

ξ created new fire modules with thread handling capabilities:
ξ »fire10one4xi
ξ »fire100one4xi
ξ »fire200one4xi
ξ »fire300one4xi
ξ »fire400one4xi
ξ »fire500one4xi
ξ »fire600one4xi
ξ »fire700one4xi
ξ »fire800one4xi
ξ »fire900one4xi
ξ »fire1000one4xi
ξ »fire1100one4xi
ξ »fire1200one4xi
ξ »fire1300one4xi
ξ »fire1400one4xi
ξ »fire1500one4xi
ξ »fire1600one4xi
ξ »fire1700one4xi
ξ »fire1800one4xi
ξ »fire1900one4xi
ξ »fire2000one4xi
ξ »fire2100one4xi
ξ »fire2200one4xi
ξ »fire2400one4xi
ξ »fire2500one4xi
ξ »fire2600one4xi
ξ »fire2700one4xi
ξ »fire2800one4xi
ξ »fire2900one4xi
ξ »fire3000one4xi
ξ » fire3100one4xi
ξ »fire3200one4xi
ξ »fire3300one4xi

ξ »test_verbkb4xi
ξ tested processes to produce (x,y,z)-coordinated via pipes and queues
ξ »verb4xi
ξ created process creating for eight directions

August 23, 2010
ξ »test_verbkb4xi
ξ tested processes to produce (x,y,z)-coordinated via pipes and queues
ξ »verb4xi
ξ created process creating for eight directions

ξ »charge2one4xi
ξ created dummy processes for direction one
ξ »charge2two4xi
ξ created dummy processes for direction two
ξ »charge2three4xi
ξ created dummy processes for direction three
ξ »charge2four4xi
ξ created dummy processes for direction four
ξ »charge2five4xi
ξ created dummy processes for direction five
ξ »charge2six4xi
ξ created dummy processes for direction six
ξ »charge2seven4xi
ξ created dummy processes for direction seven
ξ »charge2eight4xi
ξ created dummy processes for direction eight

ξ »fire2one4xi
ξ handles direction one
ξ »fire2two4xi
ξ handles direction two
ξ »fire2three4xi
ξ handles direction three
ξ »fire2four4xi
ξ handles direction four
ξ »fire2five4xi
ξ handles direction five
ξ »fire2six4xi
ξ handles direction six
ξ »fire2seven4xi
ξ handles direction seven
ξ »fire2eight4xi
ξ handles direction eight

ξ »shoot2three
ξ fixed bug

August 17, 2010
ξ reviewed the modules to build 3D verb spheres for visualization
ξ programmed process communication methods with queus and pipes for verb4xi.py
ξ »verb4xi
ξ coordinate_tenses4xi-function; color_tenses4xi-function; class Verb4Xi; coordinate_tenses4xi(reason_file); Colors2Verbs = color_tenses4xi()
ξ »test_sphere4xi
ξ an excellent model to manage processes, threads, queues, pipes and to produce statistics for verification of results
ξ »load2eight4xi.py
ξ loading (x-,y-,z-) coordinates to RAM from files
ξ »shoot2eight4xi.py
ξ defining (x-,y-,z-) coordinates coordinates in RAM dictionaries
ξ »test_verbkb4xi
ξ ok; in Utility Tester profile; produces scope-reason-test-skeleton-print4xi.xml
ξ »scope-reason-test-skeleton-print4xi.xml
ξ ok; output; (x,y,z)-coordinates produced need tuning to be suitable to 8 directions; link to message could be added; skeleton good to show all verbs
ξ »reason-test-skeleton-print4xi.xml
ξ ok; input; reason XML file where verbs are in alphabetic - not ordernumber - order

August 5, 2010
ξ »load2eight4xi.py
ξ loading (x-,y-,z-) coordinates to RAM from files
ξ »shoot2eight4xi.py
ξ defining (x-,y-,z-) coordinates coordinates in RAM dictionaries
ξ »verb4xi
ξ compilation and loading of (x-,y-,z-) coordinates either from RAM with shoot2eight4xi.py or from files with load2eight4xi.py
ξ deleted global definitions of eight and replaced with import either from shoot2eight or load2eight
ξ »import4xi.py
ξ added new imports [L] and also updated batch runs t4l.bat and c_all4xi.bat to compile new modules
ξ run $$ Verbs $$ in Utility Tester profile M1
ξ »test_verbkb4xi.py
ξ verified run and moved coordinates to directories to be imported to verb4xi.py
ξ »test_verbkb4xi.txt

August 4, 2010
ξ »load2seven4xi.py
ξ loading (x-,y-,z+) coordinates to RAM from files
ξ »shoot2seven4xi.py
ξ defining (x-,y-,z+) coordinates coordinates in RAM dictionaries
ξ »verb4xi
ξ compilation and loading of (x-,y-,z+) coordinates either from RAM with shoot2seven4xi.py or from files with load2seven4xi.py
ξ deleted global definitions of seven and replaced with import either from shoot2seven or load2seven
ξ »import4xi.py
ξ added new imports [L] and also updated batch runs t4l.bat and c_all4xi.bat to compile new modules
ξ run $$ Verbs $$ in Utility Tester profile M1
ξ »test_verbkb4xi.py
ξ verified run and moved coordinates to directories to be imported to verb4xi.py
ξ »test_verbkb4xi.txt

August 3, 2010
ξ »load2six4xi.py
ξ loading (x-,y+,z-) coordinates to RAM from files
ξ »shoot2six4xi.py
ξ defining (x-,y+,z-) coordinates coordinates in RAM dictionaries
ξ »verb4xi
ξ compilation and loading of (x-,y+,z-) coordinates either from RAM with shoot2six4xi.py or from files with load2six4xi.py
ξ deleted global definitions of six and replaced with import either from shoot2six or load2six
ξ »import4xi.py
ξ added new imports [L] and also updated batch runs t4l.bat and c_all4xi.bat to compile new modules
ξ run $$ Verbs $$ in Utility Tester profile M1
ξ »test_verbkb4xi.py
ξ verified run and moved coordinates to directories to be imported to verb4xi.py
ξ »test_verbkb4xi.txt

August 2, 2010
ξ »load2five4xi.py
ξ loading (x-,y+,z+) coordinates to RAM from files
ξ »shoot2five4xi.py
ξ defining (x-,y+,z+) coordinates coordinates in RAM dictionaries
ξ »verb4xi
ξ compilation and loading of (x-,y+,z+) coordinates either from RAM with shoot2five4xi.py or from files with load2five4xi.py
ξ deleted global definitions of five and replaced with import either from shoot2five or load2five
ξ »import4xi.py
ξ added new imports [L] and also updated batch runs t4l.bat and c_all4xi.bat to compile new modules
ξ run $$ Verbs $$ in Utility Tester profile M1
ξ »test_verbkb4xi.py
ξ verified run and moved coordinates to directories to be imported to verb4xi.py
ξ »test_verbkb4xi.txt

July 30, 2010
ξ »load2four4xi.py
ξ loading (x+,y+,z-) coordinates to RAM from files
ξ »shoot2four4xi.py
ξ defining (x+,y+,z-) coordinates coordinates in RAM dictionaries
ξ »verb4xi
ξ compilation and loading of (x+,y+,z-) coordinates either from RAM with shoot2four4xi.py or from files with load2four4xi.py
ξ deleted global definitions of four and replaced with import either from shoot2four or load2four
ξ »import4xi.py
ξ added new imports [L] and also updated batch runs t4l.bat and c_all4xi.bat to compile new modules
ξ run $$ Verbs $$ in Utility Tester profile M1
ξ »test_verbkb4xi.py
ξ verified run and moved coordinates to directories to be imported to verb4xi.py
ξ »test_verbkb4xi.txt

July 29, 2010
ξ »load2three4xi.py
ξ loading (x+,y+,z-) coordinates to RAM from files
ξ »shoot2three4xi.py
ξ defining (x+,y+,z-) coordinates coordinates in RAM dictionaries
ξ »verb4xi
ξ compilation and loading of (x+,y+,z-) coordinates either from RAM with shoot2three4xi.py or from files with load2three4xi.py
ξ deleted global definitions of three and replaced with import either from shoot2three or load2three
ξ »import4xi.py
ξ added new imports [L] and also updated batch runs t4l.bat and c_all4xi.bat to compile new modules
ξ run $$ Verbs $$ in Utility Tester profile M1
ξ »test_verbkb4xi.py
ξ verified run and moved coordinates to directories to be imported to verb4xi.py
ξ »test_verbkb4xi.txt

July 28, 2010
ξ »load2two4xi.py
ξ loading (x+,y-,z-) coordinates to RAM from files
ξ »shoot2two4xi.py
ξ defining (x+,y-,z-) coordinates coordinates in RAM dictionaries
ξ »verb4xi
ξ compilation and loading of (x+,y-,z-) coordinates either from RAM with shoot2two4xi.py or from files with load2two4xi.py
ξ »import4xi.py
ξ added new imports [L] and also updated batch runs t4l.bat and c_all4xi.bat to compile new modules
ξ run $$ Verbs $$ in Utility Tester profile M1
ξ »test_verbkb4xi.py
ξ verified run and moved coordinates to directories to be imported to verb4xi.py
ξ »test_verbkb4xi.txt

July 27, 2010
ξ »verb4xi
ξ added conditional compilation and loading of (x,y,z) coordinates either from RAM with shoot2one4xi.py or from files with load2one4xi.py
ξ moved coordinate generation to the beginning of coordinate_tenses4xi-function
ξ »charge2one4xi.py
ξ edited as stub for processes to be used by verb4xi.py to load (x,y,z)-coordinates
ξ »load2one4xi.py
ξ left 3300 as one load example
ξ »shoot2one4xi.py
ξ defined (x,y,z) coordinates as constants from load2one4xi.py to faster access by verb4xi.py
ξ »import4xi.py
ξ added new imports and also updated batch runs to compile new modules

July 26, 2010
ξ »charge2one4xi.py
ξ »load2one4xi.py
ξ »shoot4xi.py
ξ programmed above programs to read shotonexxxxxxxx4xi.txt files to RAM

July 24, 2010
ξ »verb4xi
ξ created globals for coordinates - initialized some of them - brainstormed how to use processes and load functions to get coordinates from files to RAM

July 23, 2010
ξ »verb4xi
ξ programmed statistics and their automatic verification for verb tense clusters and super-clusters
ξ »scope-reason-test-skeleton-print4xi.xml
ξ statistics are ok; coordinates with layers to be upgraded

July 22, 2010
ξ »verb4xi
ξ updated function coordinate_tenses4xi of verb4xi.py
ξ analyzed the challenge with verb dictionaries where cluster in defined for tense 2 - for example Verb2a4Xi = {...'cluster-abbreviated': 19 ...
ξ a) tense read can be any of 1...4 and it is difficult to deduct tense 2 from other tenses
ξ b) existing modules verb2a4xi, verb2b4xi ... verb2_4xi should be kept as they are
ξ c) adding new modules to verbs on the other hand dublicates where verbs are defined !
ξ d) it is super-cluster - not cluster - which defines the direction 1...8 in 3D
ξ created programs cluster2a4xi.py ... cluster2_4xi.py which defines clusters for all verb tenses:
ξ »cluster2a4xi.py
ξ »cluster2b4xi.py
ξ »cluster2c4xi.py
ξ »cluster2d4xi.py
ξ »cluster2e4xi.py
ξ »cluster2f4xi.py
ξ »cluster2g4xi.py
ξ »cluster2h4xi.py
ξ »cluster2i4xi.py
ξ »cluster2j4xi.py
ξ »cluster2k4xi.py
ξ »cluster2l4xi.py
ξ »cluster2m4xi.py
ξ »cluster2n4xi.py
ξ »cluster2o4xi.py
ξ »cluster2p4xi.py
ξ »cluster2q4xi.py
ξ »cluster2r4xi.py
ξ »cluster2s4xi.py
ξ »cluster2t4xi.py
ξ »cluster2u4xi.py
ξ »cluster2v4xi.py
ξ »cluster2w4xi.py
ξ »cluster2x4xi.py
ξ »cluster2y4xi.py
ξ »cluster2z4xi.py
ξ »cluster2_4xi.py

July 21, 2010
ξ selected modules to build 3D verb spheres for visualization
ξ »test_sphere4xi
ξ contains excellent models to manage processes, threads, queues, pipes and to produce statistics for verification of results
ξ »gun2zero4xi ...
ξ to create a dummy process object
ξ »shoot2zero4xi ...
ξ load2zero4xi.py ... to read shot a file
ξ »verb4xi
ξ coordinate_tenses4xi-function; color_tenses4xi-function; class Verb4Xi; coordinate_tenses4xi(reason_file); Colors2Verbs = color_tenses4xi()
ξ »test_verb4xi
ξ ok; in Utility Tester profile; produces scope-reason-test-skeleton-print4xi.xml
ξ »scope-reason-test-skeleton-print4xi.xml
ξ ok; output; (x,y,z)-coordinates produced need tuning to be suitable to 8 directions; link to message could be added; skeleton good to show all verbs
ξ »reason-test-skeleton-print4xi.xml
ξ ok; input; reason XML file where verbs are in alphabetic - not ordernumber - order

June 29, 2010
ξ created statistics and verified the generations of coordinates from the produced files
ξ # ========================================================================================================================
ξ # STATISTICS - TIME: 06:51:09 06/29/10 Pacific Daylight Time
ξ # COUNT2LINES4ONE : 8066 = 4033 SHOTS = 15 %
ξ # COUNT2LINES4TWO : 7276 = 3638 SHOTS = 13 %
ξ # COUNT2LINES4THREE : 5712 = 2856 SHOTS = 10 %
ξ # COUNT2LINES4FOUR : 5984 = 2992 SHOTS = 11 %
ξ # COUNT2LINES4FIVE : 6120 = 3060 SHOTS = 11 %
ξ # COUNT2LINES4SIX : 5984 = 2992 SHOTS = 11 %
ξ # COUNT2LINES4SEVEN : 6528 = 3264 SHOTS = 12 %
ξ # COUNT2LINES4EIGHT : 6528 = 3264 SHOTS = 12 %
ξ # ========================================================================================================================
ξ #
ξ # (STEP 8Q9/33) OF TEST_SPHERE4XI - COUNT2LINES4ALL: 52198 = 26099 SHOTS = 100%
ξ # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
ξ # ========================================================================================================
ξ # CONCLUDED: SHOTS4ALL = 26099 WITH 33+1=34 LAYERS, SHOTS PER LAYER = 767
ξ # CONCLUDED: 8 DIRECTIONS = 3262 SHOTS PER DIRECTION
ξ # CONCLUDED: 34 LAYERS = 3262 SHOTS IN EACH LAYER PER DIRECTION
ξ # ESTIMATED 33 LAYERS WITH DISTANCE 100, EACH CA 80 SHOTS TO 8 DIRECTIONS = 21120 SHOTS
ξ # ESTIMATED 10 LAYERS WITH DISTANCE 10, EACH CA 80 SHOTS TO 8 DIRECTIONS = 6400 SHOTS
ξ # ESTIMATED TOTAL: 27520 SHOTS
ξ # ========================================================================================================
ξ # PRODUCED: 26099 SHOTS = 94 %
ξ # ========================================================================================================

June 28, 2010
ξ programmed test 8 which read all generated files building sphere2all4xi.txt
ξ »test_sphere4xi

June 25, 2010
ξ programmed and tested gun2zero4xi and shoot2zero4xi for MainProcess4Xi generating origin2zero ... eight4xi.txt files
ξ explored in test 7 of test_sphere4xi shooting between core and the first layers

ξ »gun2zero4xi
ξ »shoot2zero4xi
ξ »test_sphere4xi

June 23, 2010
ξ generated 33 layers with distances from 100 to 3300- each layer with 8 slots - each slot with 100 shots

ξ »gun2one4xi
ξ »gun2two4xi
ξ »gun2three4xi
ξ »gun2four4xi
ξ »gun2five4xi
ξ »gun2six4xi
ξ »gun2seven4xi
ξ »gun2eight4xi

ξ »shoot2one4xi
ξ »shoot2two4xi
ξ »shoot2three4xi
ξ »shoot2four4xi
ξ »shoot2five4xi
ξ »shoot2six4xi
ξ »shoot2seven4xi
ξ »shoot2eight4xi

ξ »test_sphere4xi
ξ »sphere4xi

June 22, 2010
ξ modularized

ξ »gun2one4xi
ξ »gun2two4xi
ξ »gun2three4xi
ξ »gun2four4xi
ξ »gun2five4xi
ξ »gun2six4xi
ξ »gun2seven4xi
ξ »gun2eight4xi

ξ »shoot2one4xi
ξ »shoot2two4xi
ξ »shoot2three4xi
ξ »shoot2four4xi
ξ »shoot2five4xi
ξ »shoot2six4xi
ξ »shoot2seven4xi
ξ »shoot2eight4xi

ξ »test_sphere4xi
ξ »sphere4xi

June 21, 2010
ξ doubled the shot in each gun and created while check in MainProcess4Xi before trying to get - get from empty queue might cause system to hang up!
ξ »test_sphere4xi
ξ »sphere4xi

June 20, 2010
ξ succeeded to complete all trials of the fift test !
ξ queues worked fine both to pass command and control as well as to put and dictionaries
ξ named pipes worked fine to pass command and control as well as syncronizing work
ξ shoot2one4xi ... shoot2eight performed well as threads
ξ gun2one4xi ... gun2eight4xi worked fine as target functions for 8 processes
ξ systematic usage of STEP-names helped a lot in debugging
ξ performance monitor helped to detect bugs in loops
ξ using DummyProcess4Xi - which uses threading - was the solution to return from target function to MainProcess4Xi
ξ load was evenly distributed between 4 cores by using 8 processes with threads in each
ξ total time to shoot layer to 8 directions was decreased to 7 min 27 seconds
ξ »test_sphere4xi
ξ »sphere4xi

June 19, 2010
ξ explored dummy processes, threads and joining
ξ »test_sphere4xi
ξ »sphere4xi

June 18, 2010
ξ shot with eight processes succeeded by shooting at the end of each target function
ξ »test_sphere4xi
ξ »sphere4xi

June 17, 2010
ξ programmed 8 processes and communication establisment with eight target functions
ξ designed command and control messages based on radio procedure words such as roger and copy using XML-tags
ξ »test_sphere4xi
ξ »sphere4xi

June 16, 2010
ξ programmed gun2one4xi functions - added 9 queues, 9 pipes - established command and control with one in test_sphere4xi.py
ξ »test_sphere4xi
ξ »test_ball4xi
ξ »sphere4xi

June 15, 2010
ξ programmed test_sphere4xi.py
ξ »test_sphere4xi
ξ »sphere4xi

June 14, 2010
ξ programmed sphere4xi.py
ξ »sphere4xi

June 11, 2010
ξ tested shoot4xi-function inside test_ball4xi.py - to be programmed to gun4xi.py
ξ »test_ball4xi.py
ξ »ball4xi.py

June 10, 2010
ξ developed and tested shoot4xi-function inside test_ball4xi.py - to be programmed to gun4xi.py
ξ »test_ball4xi.py
ξ »ball4xi.py

June 4, 2010
ξ developed and tested smart shooting with 8 (x+/+,y+/-,z+/-) slots in test_ball4xi.py - to be programmed to gun4xi.py
ξ »test_ball4xi.py
ξ »ball4xi.py

June 2, 2010
ξ shot (X+,Y+,Z+) and X-,Y+,Z+) - 2/8 aimed shot series done
ξ no double shots anymore, shooting to a layer works
ξ »test_ball4xi.py
ξ »ball4xi.py

June 1, 2010
ξ explored shooting layers and minimizing misses
ξ »test_ball4xi.py
ξ »ball4xi.py

May 31, 2010
ξ shot several layers
ξ »test_ball4xi.py
ξ »ball4xi.py

May 30, 2010
ξ shot several shots varying both azimuth and elevation angles as well as distance
ξ »test_ball4xi.py
ξ »ball4xi.py

May 29, 2010
ξ programmed and tested area2shot
ξ »test_ball4xi.py
ξ »ball4xi.py

May 28, 2010
ξ process name created to ball and shot - goal to genereate process glaxies
ξ verb setting for shot
ξ »test_ball4xi.py
ξ »ball4xi.py

May 27, 2010
ξ implemented test_ball4xi.py which creates queues, pipes and processes for ball, shot, cluster and super-cluster
ξ each process handles its own ball thereby mimicing glaxies and works as a framework to coorninate objects (nouns) from ace-xml files
ξ »test_ball4xi.py
ξ »ball4xi.py

May 26, 2010
ξ used multiprocessing for test_ball4xi.py by creating queues, pipes and processed for ball, shot, cluster and super-cluster
ξ »test_ball4xi.py
ξ »ball4xi.py

May 25, 2010
ξ started to use multiprocessing for test_ball4xi.py and created queues, pipes and processed for ball, shot, cluster and super-cluster
ξ added and tested message2ball and message2shot attributes
ξ »test_ball4xi.py
ξ »ball4xi.py

May 24, 2010
ξ uploaded to server both studio4xi and sw4xi

May 23, 2010
ξ programmed distance2shot
ξ »test_ball4xi.py
ξ »ball4xi.py

May 22, 2010
ξ shot with different elevation and azimuth angles !
ξ »test_ball4xi.py
ξ »ball4xi.py

May 21, 2010
ξ succeeded to shoot with elevation and azimuth angles !
ξ »test_ball4xi.py
ξ »ball4xi.py

May 20, 2010
ξ added time-attribute to Spehere4Xi and programmed shot »ball4xi.py

May 19, 2010
ξ tested nine Spehere4Xi attributes: 'verb', 'id','xorigin','yorigin','zorigin','radius','volume','area','color'
ξ updated »test_ball4xi.py
ξ added features such as volume and area for Sphere4Xi »ball4xi.py

May 18, 2010
ξ programmed »test_ball4xi.py
ξ programmed »ball4xi.py
ξ created cluster and super-cluster statistics for verbs »verb4xi.py
ξ »scope-reason-test-skeleton-print4xi.xml

May 16, 2010
ξ completed coordinating verbs »verb4xi.py
ξ »scope-reason-test-skeleton-print4xi.xml

May 15, 2010
ξ took into use new RDF-attributes for tense 1 with coordinates »verb4xi.py
ξ »scope-reason-test-skeleton-print4xi.xml

May 14, 2010
ξ completed tense 1 with coordinates »verb4xi.py
ξ »scope-reason-test-skeleton-print4xi.xml

May 13, 2010
ξ tested coordinate building and stopped to brainstorm better solution for coordinates and to explore input validity for tense 1
ξ updated print4xi.py order format-function »print4xi.py
ξ run all tests due to print4xi.py update

May 12, 2010
ξ upgraded verb4xi.py to produce 3D skeleton for verbs »verb4xi.py
ξ »scope-reason-test-skeleton-print4xi.xml

May 11, 2010
ξ programmed coordinate_tenses4xi function and coordinate_tenses method in »verb4xi.py
ξ test coordinates »Scopes to Verbs
ξ test coordinates »Colors, Mavericks and Waves
ξ »skeleton_print4xi.py
ξ »reason-verb4xi.xml

consider:
ξ x+ = step = time simulation; all available different steps are defined indirectly by skeleton_print4xi.py
ξ z+ = ing
ξ y+ = with positive reference, y- = with negative reference
ξ skeleton_print4xi.py defines ALL available trace messages with valid verbs for tracing
ξ creating HTML-file with style sheet and putting colors to one table

May 10, 2010
ξ programmed color_tenses4xi function and color_tenses method in »verb4xi.py
ξ tested colors »Colors, Mavericks and Waves

May 8, 2010
ξ developed wave_verb4xi function method in »verb4xi.py

May 7, 2010
ξ explored how to produce XML for Flash »color2verbs4xi

May 5, 2010
ξ completed »verb4xi.py

May 4, 2010
ξ updated ξ »verb4xi.py to check and to process verbs
ξ »color2verbs4xi

May 3, 2010
ξ created HTML presentation for verbs
ξ »color2verbs4xi
ξ upgraded all verbs making them more efficient to handle, deleted double keys and and added some tenses
ξ »verb4xi.py
ξ »verb2h4xi.py
ξ »test_verbkb4xi.py

May 1, 2010
ξ upgrade tense4 to all verbs, create XML-file according to new verb descriptios and test
ξ »verb4xi.py
ξ »verb2h4xi.py
ξ »test_verbkb4xi.py

April 30, 2010
ξ upgraded verbs and their test
ξ »verb4xi.py
ξ »verb2h4xi.py
ξ »test_verbkb4xi.py

April 29, 2010
ξ invented numbering system for 3D symbols of verbs

April 28, 2010

ξ decided that tense is the right attribute for verbs
ξ past, present and future are NOT the only tenses but there is also the ing-tense
ξ tense definition: a temporal linguistic quality expressing the time at, during, or over which a state or action denoted by a verb occurs
ξ present continuous tense is the ing-form of the verb
ξ edited all verb2*4xi.p? macros; added symbol for each tense (1-3, do has four)
ξ created verbalize4xi.py in Studio4Xi
ξ tagged Studio4Xi programs and created keyboard macros in Assistant for Studio -profile to run them
ξ added some verbs such as queue and created usage information for each verb:
ξ »verb2z4xi.py

April 27, 2010
ξ embedded presentation info inside each verb - keeping the strategy that programs contain the information, example:
ξ »verb2h4xi.py

April 26, 2010
ξ decided to embed presentation info inside each verb - keeping the strategy that programs contain the information
ξ discovered Webster lacking some technical verbs such as upgrade and some verbs developed somehor such as rename !
ξ updated all verbs and upgraded their macros, see for example:
ξ »verb2a4xi.py
ξ remove born-verb and replace borning with rising and consider activated by rose in ALL modules
ξ »print_skeleton4xi.py

ξ find and replace assert with accept and proper action in ALL modules

April 24, 2010
ξ tested limit2loop4xi »loop4xi.py
ξ »hello_world4xi.py - process alive status ok
ξ »test_pipe1_mp_xi4.py - results ok
ξ updated »TIP
ξ searched while loops with count2try and updated to use limit2loop4xi-function the following modules:
ξ »popen4xi.py
ξ »answer_challenge4xi.py
ξ »applyresult4xi.py
ξ »deliver_challenge4xi.py
ξ »pipelistener4xi.py
ξ »syncmanager4xi.py
ξ »pipeclient4xi.py

ξ replaced assert with accept and proper action in »process4xi.py
ξ updated pickle2*4xi.py setting all to be traced and run all tests using Utility Tester profile
ξ programmed »loop4xi.py
ξ upgraded »test_manager4xi.py

April 23, 2010
ξ reasoned:
ξ a) there is need for tuning timeouts and giving time to others - as timeout4xi.py and sleep4xi.py offer !
ξ b) subprocess (which also exists under /lib!) and _subprocess has PEPS and development is going on - for example async is not real async (verified also in our tests)
ξ added omega2sleep to return phase of Process4Xi-methods

ξ analyzed popen4xi.py wait-method and process4xi.py is_alive-method - bugs have been found in _subprocess
ξ improved process4xi.py by adding sleep times and by updating is_alive-method of Process4Xi
ξ analyze how to change test_pipe1_mp_xi4.py so that it would direct application info to XML-file - this would make it faster to compare results between three multiprocessing!
ξ upgrade sense method of CurrentProcess4Xi needs upgrading - it should be able to provide get info from object methods
ξ analyze, change and optimize the usage of CurrentProcess4Xi when necessary - looks like you can delete some function imports, start in process4xi.py and see find4py.txt !

April 22, 2010
ξ upgraded hello_world4xi.py revealed that:
ξ 1. test program became the current process as wanted and even the manager server !
ξ 2. sense method of CurrentProcess4Xi needs upgrading - it should be able to provide get info from object methods
ξ 3. usage of CurrentProcess4Xi needs detailed analysis - looks like you can delete function imports in process4xi.py - see find4py.txt !
ξ
ξ upgraded hello_world4xi.py to command current process object with the same commands as normap process object
ξ there might become need to test both parameters of CurrentProcess4Xi:
ξ def __init__(self, caller_type):
ξ # self = the caller of this class,
ξ # caller_type = True = it's a process object type such as Process4Xi wanting to make it's self to _current_process
ξ # = False = it's a module such as a test program wanting to make MainProcess4Xi to _current_process

decided to get the status of process right as follows:
ξ a) to upgrade test_current_process4xi so that it tests Processes4Xi without Manager4Xi, to check alive status and to sense it all the time
ξ b) to test all methods of Process4Xi
ξ c) to improve sensing in Process4Xi with classes it uses
ξ d) to try getting more information about threading

ξ examined what the process status alive should show:
1. False
ξ after process creation
2. True
ξ after prosess a) start b) run and c) terminate (!)

ξ started to examine why process4xi status is ALWAYS False ?
hello_world4xi:
ξ { Process4Xi : __repr__ ; (Step 1/3d2) set; status-set-by-repr-of-Process4Xi to: 0; time: 06:54:55 04/19/10 Pacific Daylight Time}
ξ { Process4Xi : __repr__ ; (Step 2/3a) decided; type-status-decided-by-repr-of-Process4Xi: ; time: 06:54:55 04/19/10 Pacific Daylight Time}
ξ { get_stopped_process4xi : get_stopped_process4xi ; started; get-stopped-process4xi-started: ; time: 06:54:55 04/19/10 Pacific Daylight Time}
ξ { get_stopped_process4xi : get_stopped_process4xi ; returning; stopped-process4xi-returning-by-get-stopped-process4xi: stopped; time: 06:54:55 04/19/10 Pacific Daylight Time}
ξ { Process4Xi : __repr__ ; (Step 2/3b) set; status-set-by-repr-of-Process4Xi to: stopped; time: 06:54:55 04/19/10 Pacific Daylight Time}

April 21, 2010

ξ upgraded and corrected constant_pool4xi.py and took it into trace for test_proxy_mp_xi4.py
ξ condired checking key in register of SyncManager4Xi to avoid double registering - original one alarmed if test program tried to set!
ξ examined _multiprocessing.PipeConnection and its usage in the system:
ξ Pipe4Xi function in pipe4xi.py has been tested with hello_pipe4xi.py - it works - Pipe4Xi calls both with NamedPipe handle and filehandle but only with duplex
ξ connection.py:
ξ c1 = _multiprocessing.PipeConnection(h1, writable=duplex)
ξ c2 = _multiprocessing.PipeConnection(h2, readable=duplex)
ξ return c1, c2
ξ pipeclient4xi.py:
ξ return _multiprocessing.PipeConnection(h2xi)
ξ however, PipeClient4Xi should NOT get None as parameter, because it will call _multiprocessing.PipeConnection with bad handle
ξ pipelistener4xi.py: <-- discovered serious bug in Python: it allows class variables to be defined outside class and to refer with class !!!
ξ return _multiprocessing.PipeConnection(handle2xi)
ξ rebuild_pipe_connection4xi.py:
ξ return _multiprocessing.PipeConnection(handle, readable=readable, writable=writable)
ξ upgrade test_pool1_mp_xi4.py and pool4xi.py - consider having only pool4xi test in test_pool1_mp_xi4.py and with one, two and four processes with own tasks !
ξ compare pool4xi.py to pool.py - pool4xi and Pool4Xi are HUGE modules and classes !!!
ξ RUN = 0, CLOSE = 1, TERMINATE = 2

April 20, 2010
ξ { Pool4Xi : _handle_tasks
ξ (Step 3/5e) yielded; thread-state-yielded-by-handle-tasks-of-Pool4Xi: ** 1 ** ; time: 06:59:29 04/20/10 Pacific Daylight Time}
ξ test_proxy_mp_xi4.py STEP 10/12B3): *** FAILED WITH RESULT2XI USING 2 WORKER PROCESSES ***
ξ added 'ApplyResult4Xi': 'ACK4TRACE' to test_proxy_mp_xi4.py
ξ pool4xi.py exploring - it does not work - challenges to keep thread state ok
ξ #worker2xi.run() i.e. not called run-method of started process; no help
ξ _handle_tasks of Pool4Xi:
ξ if thread._state (== 1) break <-- pass and yielded warning - perhaps state = 1 because we used run-command !?
if thread state == 1 then it does not do any good/help to put some stuff:
ξ { ApplyResult4Xi : wait ; (Step 3/5e) yielded; thread-state-yielded-by-handle-tasks-of-Pool4Xi: ** 1 ** ; time: 04:49:08 04/20/10 Pacific Daylight Time}
ξ { ApplyResult4Xi : wait ; performed; condition-acquire-of-applyresult2xi-performed-by-wait-of-ApplyResult4Xi: ξ { ApplyResult4Xi : get ; yielded; nack2readyt-yielded-by-get-of-ApplyResult4Xi: True; time: 04:49:10 04/20/10 Pacific Daylight Time}

ξ consider removing process run-command inside the system even if you use it in tests !
ξ TEST VERSION Release 4.17, WHICH ALLOWS TRANSPARENTLY SELECT BETWEEN ORIGINAL AND DRAGONIZED MULTIPROCESSING !
ξ explore examine4xi and how tuninh it affects to tests
ξ combination of new and old modules may reveal some bugs in the system !
ξ tune examamine4xi and Lock4Xi to fix { Lock4Xi : __repr__ ; (Step 7/7) returning; lock-owner-returning-by-repr-of-Lock4Xi: None; time: 06:02:44 04/19/10 Pacific Daylight Time}
ξ explore namespace in test_locks_mp_xi4.py
ξ explore tests such as test_conditionproxy4xi
ξ IT IS NOW THE ORIGINAL SYNCMANAGER.REGISTER which does NOT accept calls such as : SyncManager4Xi.register('Condition4Xi', threading.Condition, ConditionProxy4Xi)
ξ explore test_dispatch4xi - connection.py / client4xi.py !
ξ explore test_current_process4xi - can't start twice

April 19, 2010
ξ continued test_proxy_mp_xi4.py (STEP 4/12A): CREATING AND STARTING MANAGER TO SENSE and check why manager is NOT started !!!
ξ deleted phase24
ξ tuned examine4xi to get profile where Manager4Xi, SyncManager4Xi and modules with them are from original multiprocessing library
ξ { Pool4Xi : _handle_tasks ; (Step 3/5e) warning; thread-state-warning-by-handle-tasks-of-Pool4Xi: ** 1 ** ; time: 06:02:36 04/19/10 Pacific Daylight Time}
ξ { Lock4Xi : __repr__ ; (Step 7/7) returning; lock-owner-returning-by-repr-of-Lock4Xi: None; time: 06:02:44 04/19/10 Pacific Daylight Time}
ξ (STEP 11/12E EXCEPTION): *** FAILED WITH ARRAYFUNCTION4XI ***
ξ ACHIEVED VERSION Release 4.17, WHICH ALLOWS TRANSPARENTLY SELECT BETWEEN ORIGINAL AND DRAGONIZED MULTIPROCESSING !

ξ
ξ LAST OF create-of-SyncManager4Xi:
ξ message2print = "{(Step 3/5e) calling" + "; Client-of-syncmanager2xi-calling-by-create-of-SyncManager4Xi: " + str(self._Client) + "; time: " + time4xi() + "}"
ξ print4xi(class2print, method2print, message2print)

April 16, 2010
ξ programmed tailor_trace4xi function and embedded into test_locks_mp_xi4.py, test_benchmark_mp_xi4.py and test_proxy_mp_xi4.py

April 15, 2010
ξ upgraded test_locks_mp_xi4.py, which is an excellent test for testing the corresponding classes in with three multiprocessing - a class is passed as a parameter !
ξ upgraded test_benchmark_mp_xi4.py, which helps to compare performance of three different multiprocessing systems - and require trace to be swicthed off !
ξ programmed deny_trace4xi into test_cpu_corecount4xi.py to deny trace during the test
ξ brainstormed the best way to tailor trace for an individual test - considered examine4xi.py kind of solution to embed in function tailor_tracexi.
ξ

April 14, 2010
ξ completed setting family parameter when client is called - surprising many modules left is unresolved when calling !
ξ completed integrating into examine4xi.py to d)client4xi.py e) current_process4xi.py f) get_preparation_data4xi.py
ξ g) listener4xi.py h) lock4xi.py i) mainprocess4xi.py j) pipe4xi.py k) popen4xi.py l) queue4xi.py
ξ l) server4xi.py m) skeleton_print4xi n)
ξ
ξ achieved the version which allows you to try original multiprocessing by editing ONE module examine4xi.py for a class/method and or function in testing the system !
ξ run all tests and corrected authkey parameter - instead of authkey=authkey kind of calling (which looks odd) just passed the parameter to _Client
ξ 1) autoproxy4xi.py 2) basemanager4xi.py 3) baseproxy4xi.py 4) dispatch4xi.py 5) remoteerror4xi.py 6) socketclient4xi.py

April 13, 2010
ξ upgraded Studio4Xi/Python/3.3/html/en_mp_sw_xi4.html, for example this chapter #070 contains only blog
ξ added join method if Process4Xi usage to test_math_mp_xi4.py - to be tested in which phase you could utilize it more

ξ explored with test_proxy_mp_xi4.py
ξ added select verb to 1) skeleton_print4xi.py and 2) to verb2s4xi.py

ξ run 3) test_skeleton4xi.py and 4) test_verbkb4xi.py, 4) run macro4xi in Studio4Xi 5) updated keyboard profiles with the new macro for functions and classes
ξ 1) created examine4xi.py to use the original multiprocessing; goal to centrally switch multiprocessing mode
ξ 2) updated a) import4xi.py b) c_all4xi.bat d)print4xi.py
ξ 3) integrated examine4xi.py to
ξ a) manager4xi.py b) syncmanager4xi.py c) process4xi.py
ξ 3) tested examine4xi.py with a) hello_world4xi.py b) test_math_mp_xi4.py
ξ a) hello_world4xi.py

April 12, 2010
ξ upgraded test_math_mp_xi4.py to handle less than four core systems to test it in less powerful systems
ξ tuned ace-math4xi.xml
ξ changed time zone to that of California
ξ fixed the bug in test_arena4xi: it called twice set_trace-function - you may reveal this kind of bug by copying code block to a working test program !
ξ upgraded test_cpu_corecount4xi.py to show Windows system being used and to produce XML-information - do NOT set trace twice lesson learned !
ξ analyzed reason-math4xi.xml - system handles challenge waves without stopping and reports:
ξ {(Step 3/7d) yielded; response-yielded-by-wait-of-Popen4Xi-Windows: 0; time: 07:53:31 04/12/10 FLE Daylight Time}
ξ {(Step 8/9q) warned; possible-IndexError-warned-by-feed-of-Queue4Xi: ** class 'IndexError' ** ; time: 07:53:29 04/12/10 FLE Daylight Time}
ξ {(Step 3/7i) warned; count2try-warned-by-wait-of-Popen4Xi-Windows: ** 9 ** ; time: 07:53:29 04/12/10 FLE Daylight Time}
ξ corrected Popen4Xi wait message to display timeout-set-by-Popen4Xi-Windows - because code handles several operating systems trace shows the one handled

April 10, 2010
ξ succeeded to pass test_math_mp_xi4.py - offers a lot of information about processes - also due to sense/reason/ace-methods !
ξ when process 1 got run first it gets about all done before other processes get run command - tuning of test needed!
ξ improved test_math_mp_xi4.py - to be solved why it TILTS !

April 9, 2010
ξ analyzed test_math_mp_xi4.py - compared to test_pipe_mp_xi4.py - why Queue4Xi fails - should it be running in process ?
ξ invented and implemented system to tag testing in pickle2*4xi.py modules, for example pickle2i4xi.py contains the following lines:

April 8, 2010
ξ MONITORED PERFORMANCE OF FOUR CPU CORES USING THE PERFORMANCE MONITOR OF LOGITECH G19 KEYBOARD DISPLAY - ALL CORES WERE IN ACTIVE USAGE DURING TESTS !
ξ considered moving StepOriginal decision to one module in the same way as timeouts and sleepong times are being solved by one module
ξ replaced performed-verb with acknowledged: in trial loops, in forkingpickler4xi.py (aargh!) to differentiate from performed-verb in reason XML-files
ξ response2xi = _subprocess.WaitForSingleObject(int(self._handle), msecs) - i.e. response is received but it is zero
ξ controlled succesfully trace amount by marking trusted and not-needed-in-trace-modules, for example timeout and wait time messages in pickle2o4xi.py: Pickle2o4Xi = {'omega2sleep4xi': 'ACK4XI', 'omega2timeout4xi': 'ACK4XI',...

April 7, 2010

challenges (including the need to review forkingpickler against pickle.py and that test .txt file has become large for editor!
ξ name-set-by-save-global-of-ForkingPickler4Xi to: #HW: Process4Xi, #PX: method <--- !???
ξ { SyncManager4Xi : start ; (Step 9/12d) hit; exception-hit-by-start-of-SyncManager4Xi: *** failed in receiving - reception_trial_counter2xi = 1 *** ; time: 18:26:28 04/07/10 FLE Daylight Time}
ξ save_global of ForkingPickler4Xi bugs corrected - has to tested
ξ { ForkingPickler4Xi : save_global ; yielded; pickling-error-of-object-yielded-by-save-global-of-ForkingPickler4Xi: *** *** ; time: 18:26:29 04/07/10 FLE Daylight Time}
ξ { ForkingPickler4Xi : save_global ; yielded; pickling-error-of-module-yielded-by-save-global-of-ForkingPickler4Xi: *** builtins *** ; time: 18:26:29 04/07/10 FLE Daylight Time}
ξ { ForkingPickler4Xi : save_global ; yielded; pickling-error-of-name-yielded-by-save-global-of-ForkingPickler4Xi: *** method *** ; time: 18:26:29 04/07/10 FLE Daylight Time}

progress:
ξ INIT-OF-POPEN4XI-WINDOWS-RETURNED AFTER PASSING ALL STEPS!
ξ MEMOIZE-PERFORMED-BY-SAVE-DICT-OF-FORKINGPICKLER4XI - MEMOIZE METHOD ADDED TO FORKINGPICKLER4XI !
ξ SAVE-DICT-OF-FORKINGPICKLER4XI-RETURNING - WITHOUT ANY EXCEPTIONS !

April 4, 2010

ξ added sensing of started process to SyncManager4Xi start-method: kb2process = self._process.sense() - to get more information
SYNCMANAGER4XI START-METHODS USES NON-DUPLEX PIPE AS FOLLOWS:
ξ #gateway-of-syncmanager2xi depicts server address
ξ wave2read, wave2write = Pipe4Xi(duplex=False)
ξ self._process = Process4Xi( # Note: run-method of Process4Xi is NOT called after start as would be done without own run-method as with server
ξ target=type(self)._run_server, # target function is the method _run_server
ξ args=(self._registry, self._address, self._authkey, # self_address to be solved
ξ self._serializer, wave2write), # wave2write handle received from Pipe4Xi is passed to Process4Xi in argument list
ξ )
ξ wave2write.close() #closing is mandatory (tested to be) - this might be because writing to pipe is done by the activated process
ξ while reception_trial_counter2xi < 8:
ξ reception_trial_counter2xi = reception_trial_counter2xi + 1
ξ try:
ξ self._address = wave2read.recv() # syncmanager2xi-object address is received via wave2read, sender wave2write works in activated process
ξ
ξ
ξ
ξ

PROCESS4XI HANDLES wave2write argument as follows:
ξ message2print = "{(Step 0/15f) passed" + "; args-passed-to-init-of-Process4Xi: " + str(args) + "; time: " + time4xi() + "}"

HELLO_PIP4XI.PY, FUNCTION HELLO_NON_DUPLEX_PIPE2XI USES NON-DUPLEX PIPE AS FOLLOWS:
ξ # -----------------------------------------------------------------------------------------
ξ # CLIENT2XI SENDS GREETING TO SERVER2XI - text message
ξ # -----------------------------------------------------------------------------------------
ξ try:
ξ wave2write.send([1, '(STEP 6/7e) OF NON DUPLEX HELLO PIPE2XI: HELLO B2XI, A2XI HERE !', None])
ξ except:
ξ ....
ξ # -----------------------------------------------------------------------------------------
ξ # SERVER2XI RECEIVES GREETING FROM CLIENT2XI - text message
ξ # -----------------------------------------------------------------------------------------
ξ try:
ξ print(wave2read.recv())
ξ except:
ξ .....
ξ # -----------------------------------------------------------------------------------------
ξ # CLIENT2XI SENDS ARRAY TO SERVER2XI - bytes message
ξ # -----------------------------------------------------------------------------------------
ξ arr1 = array.array('i', range(5))
ξ arr2 = array.array('i', [0] * 10)
ξ try:
ξ wave2write.send_bytes(arr1)
ξ except:
ξ ....
ξ # -----------------------------------------------------------------------------------------
ξ # SERVER2XI RECEIVES ARRAY FROM CLIENT2XI - bytes message
ξ # -----------------------------------------------------------------------------------------
ξ try:
ξ count = wave2read.recv_bytes_into(arr2)
ξ except:
ξ ....

ξ concluded that non-duplex pipe works, also used by Queue4Xi as follows self._reader, self._writer = Pipe4Xi(duplex=False)
ξ hello_pipe4xi.py tested both duplex and non-duplex with standard, dragon2xi and dragon4xi multiprocessing
ξ non-duplex call: wave2read, wave2write = Pipe4Xi(duplex=False), where wave2read gives possibility to ONLY read/receive and is for SERVER, whereas wave2writer is for CLIENT
ξ no close required for non-duplex mode, hello_non_duplex_pipe2xi calls as follow: wave2read, wave2write = Pipe2Xi(duplex=False)

ξ renamed handle- to surfboard and address to wave2pipe in Pipe4Xi
ξ renamed serializer to force2manager, authkey to passport2manager and address to gateway2sync in manager4xi.py - to reduce synonyms

April 3, 2010
ξ must limit giving values in parameter list if None is giving and to force callers to define values
ξ must drop number of optional parameters in system

ξ CRITICAL STEP TO BE SOLVED - _MULTIPROCESSING.PIPECONNECTION FAILS !!!!
ξ message2print = "{(Step 9/12a) calling" + "; reader2xi-recv-calling-by-start-of-SyncManager4Xi: " + str(reader2xi.recv) + "; time: " + time4xi() + "}"
ξ print4xi(class2print, method2print, message2print)
ξ #PX:

April 3, 2010
ξ made manager4xi create parameters to SyncManager4Xi and changed SyncManager __init__ to require parameters

ξ problems in SyncManager4Xi can now be seen in Manager4Xi function and mountain2dragonxi does not get confused to other data
ξ { SyncManager4Xi : start ; (Step 9/12d) hit; exception-hit-by-start-of-SyncManager4Xi: *** failed in receiving - reception_trial_counter2xi = 32 ***
ξ SyncManager4Xi : start ; (Step 9/12d) hit; exception-hit-by-start-of-SyncManager4Xi: *** failed in receiving - reception_trial_counter2xi = 33 *** ; time: 11:03:43 04/03/10 FLE Daylight Time}
ξ
ξ { SyncManager4Xi : start ; (Step 10/1a) calling; reader2xi-close-calling-by-start-of-SyncManager4Xi: ; time: 11:03:43 04/03/10 FLE Daylight Time}
ξ { SyncManager4Xi : start ; (Step 11/12) set; state-value-of-syncmanager2xi-set-by-start-of-SyncManager4Xi to: 1; time: 11:03:43 04/03/10 FLE Daylight Time}
ξ Manager4Xi : Manager4Xi ; (Step 4/5) hit; dragon2xi-hit-by-Manager4Xi: *** *** ; time: 11:03:43 04/03/10 FLE Daylight Time}

ξ upgraded manager4xi.py so that Manager4Xi creates mountain2dragonxi which is given as parameter; dragon2xi = SyncManager4Xi(mountain2dragonxi)
ξ changed SyncManager parameter address name to mountain and forced it to be mandatory!
def __init__(self, mountain, authkey=os.urandom(32), serializer='pickle'):
ξ upgraded Listener4Xi: __init__ as follows:
ξ if address is None:
ξ family2xi = PipeListener4Xi._cf2xi.get_default_family() #dragonized by forcing to the right family!
ξ address = arbitrary_address4xi(family2xi) #dragonized by forcing an address
ξ self._address = address
ξ explored address and who sets it:
ξ Listener4Xi:
ξ __init__:
ξ address = address or arbitrary_address4xi(family) # if address is not given as parameter, an arbitrary address is being built
ξ self._listener = PipeListener4Xi(address, backlog)
ξ connection.py, class Listenr, method __init__ address = address or arbitrary_address(family)

April 1, 2010

ξ CMD/M3/test_dispatch4xi.py; says nothing !!!
ξ CMD/M2/test_all_methods4xi.py; STEP 12/33a STARTING RECEIVING 15 MESSAGES FROM PIPE2XI CONSUMER CHANNEL - tilts !?
ξ CMD/M1/G3 test_valueproxy4xi loops in SockecClient4Xi step 5/12a passing localhost and 8080 - is socket for Unix ?
ξ upgraded deliver_challenge4xi.py with while, trials, sleep times ...
ξ changed constant_connection4xi.py setting to original values: MESSAGE_LENGTH = 20, MAX_RESPONSE_MESSAGE_LENGTH = 256, BUFSIZE = 8192
ξ explored listener4xi.py - moved Listener4Xi constant objects to class variables - creccted bug unnoticed by Python; deliver_challenge to deliver_challenge4xi
ξ explored client4xi.py - returns a connection to the address of a Listener i.e. address to be passed to this programs should give a proper address to Listener !!!
ξ upgraded state4xi.py by removing extra imports
ξ added checkings, try-except blocks to SyncManager4Xi
ξ added statistics to SyncManager4Xi
ξ examined type2xi = type(self).from_address, (self._address, self._authkey, self._serializer)
ξ examamined close-usage with pipe to server - may be because the pipe on NOT duplex ?
ξ process4xi.run is NOT mandatory if you program your own way to call the target passed to Process4Xi - as is doen by SyncManager !
ξ studied possibility to move registry creation from __init__ to sharable and let compiler to initialize it - might save time if several managers
ξ explored callable and why some callables get sense, reason, ace although they are not 4xi-types
ξ analyzed register of SyncManager4Xi: typeid becomes callable class/function and should be of 4Xi-type if not common
ξ analyzed manager4xi.py and upgraded it to sense the create SyncManager4Xi object and to trace knowledge base

March 31, 2010
ξ added try and object identification to sense, reason and ace methods in ALL programs to make sure they don't cause any problems and that their info can be combined to knowledge base
ξ changed to comments Step-level debugging because it gives to much "noise" to trace
ξ explored test_all_methods4xi.py - again it is the famous address unresolved to None and causing test failure !
ξ and it requires manager object to be ok before they can be used to create process4xi objects !
ξ all_methods4xi(manager2xi)) gave the following methods for SyncManager4Xi object - note the first line with classes as methods !

ξ 'Array4Xi', 'BoundedSemaphore4Xi', 'Condition4Xi', 'Event4Xi', 'JoinableQueue4Xi', 'Lock4Xi', 'Namespace4Xi', 'Pool4Xi', 'Queue4Xi', 'RLock4Xi', 'Semaphore4Xi', 'Value4Xi',
ξ '_Client', '_Listener', '_Server',
ξ '__class__', '__delattr__', '__enter__', '__eq__', '__exit__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__',
ξ '__init__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__',
ξ '__weakref__', '_create', '_debug_info', '_finalize_manager', '_number_of_objects',
ξ '_run_server', 'ace', 'connect', 'dict', 'get_server', 'join', 'list', 'reason', 'register', 'sense', 'shutdown', 'start']
ξ it the register which is extremely difficult to read because of so many optional elements and the variety of element values:

ξ KEY
ξ { 'AsyncResult': (None, None, None, ),
ξ 'Condition4Xi': (, ('wait', 'notify', 'notify_all', 'sense', 'reason', 'ace'), None, ),
ξ 'Event4Xi': (, ('is_set', 'set', 'clear', 'wait', 'sense', 'reason', 'ace'), None, ),
ξ 'Iterator': (None, ('send', 'throw', 'close', 'sense', 'reason', 'ace'), None, ),
ξ 'BoundedSemaphore4Xi': (, ('acquire', 'release', 'sense', 'reason', 'ace'), None, ),
ξ 'Array4Xi': (, ('__len__', '__getitem__', '__setitem__'), None, ),
ξ 'list': (, ('sense', 'reason', 'ace'), None, ),
ξ 'Queue4Xi': (, None, None, ),
ξ 'Pool4Xi': (, ('apply', 'apply_async', 'close', 'imap', 'imap_unordered', 'join', 'map', 'map_async', 'terminate', 'sense', 'reason', 'ace'), {'apply_async': 'AsyncResult', 'imap_unordered': 'Iterator', 'imap': 'Iterator', 'map_async': 'AsyncResult'}, ),
ξ 'Lock4Xi': (, ('acquire', 'release', 'sense', 'reason', 'ace'), None, ),
ξ 'Semaphore4Xi': (, ('acquire', 'release', 'sense', 'reason', 'ace'), None, ),
ξ 'RLock4Xi': (, ('acquire', 'release', 'sense', 'reason', 'ace'), None, ),
ξ 'dict': (, ('__contains__', '__delitem__', '__getitem__', '__len__', '__setitem__', 'clear', 'copy', 'get', 'has_key', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values', 'sense', 'reason', 'ace'), None, ),
ξ 'JoinableQueue4Xi': (, None, None, ),
ξ 'Value4Xi': (, ('get', 'set', 'sense', 'reason', 'ace'), None, ),
ξ 'Namespace4Xi': (, ('__getattribute__', '__setattr__', '__delattr__', 'sense', 'reason', 'ace'), None, )},

ξ upgraded SyncManager4Xi.py class variables to get initialized when the class is called first time
ξ added run-command to worker2xi in pool4xi.py
ξ added run-command to process in basemanager4xi.py
ξ added run-command to process in test_all_methods4xi.py, test_sharedctypes4xi.py,

March 30, 2010
ξ TEST_PIPE1_MP_XI4.PY PASSED !
ξ ACE4XI PASSED OK
ξ REASON4XI PASSED OK
ξ SENSE4XI PASSED OK

Notes:
a) unable to save empty dictionary - Python 3.3 has some challenges adding to empty dictionaries - this problem might be a common one !?
ξ { ForkingPickler4Xi : save_dict ; passing; EMPTY-DICT-passing-to-write-by-save-dict-of-ForkingPickler4Xi: b'}'; time: 17:20:51 03/30/10 FLE Daylight Time}
ξ { ForkingPickler4Xi : save_dict ; performed; write-performed-by-save-dict-of-ForkingPickler4Xi: ; time: 17:20:51 03/30/10 FLE Daylight Time}
ξ { ForkingPickler4Xi : save ; (Step 3/9f) hit; function-hit-by-save-of-ForkingPickler4Xi: *** *** ; time: 17:20:51 03/30/10 FLE Daylight Time}

b) it was a good idea to add while-wait loops which give time to others - some while loops still exceed 8 times which propably is ok:
ξ { Popen4Xi : wait ; (Step 3/7i) warned; count2try-warned-by-wait-of-Popen4Xi-Windows: ** 9 ** ; time: 17:20:51 03/30/10 FLE Daylight Time}

c) its better to yield instead of raise - you can print either yielded or hit trace message - for example:
ξ { Popen4Xi : wait ; (Step 3/7d) yielded; res-yielded-by-wait-of-Popen4Xi-Windows: 0; time: 17:20:50 03/30/10 FLE Daylight Time}
ξ { Popen4Xi : wait ; (Step 3/7e) upgraded; milliseconds-upgraded-by-wait-of-Popen4Xi-Windows: 1800; time: 17:20:50 03/30/10 FLE Daylight Time}
ξ { Popen4Xi : __init__ ; (Step 7/8p) hit; exception-hit-by-init-of-Popen4Xi-Windows: *** function: process_obj: to_child2xi: <_io.BufferedWriter name=4> HIGHEST_PROTOCOL: 3 *** ; time: 17:20:50 03/30/10 FLE Daylight Time}

d) noticed that you have to receive as many messages as has been sent, no more or less !
ξ upgraded test_pipe1_mp_xi4.py for phased logic which required global variables
ξ add reason4xi and ace4xi functions as well as tags to test_pipe1_mp_xi4.py
ξ review Process4Xi usage and make sure start, run, terminate and join methods are being used correctly, boot-method is necessary !

e) its a good idea to use shared class variables for example for constants and for shared registers:
ξ {(Step 1/7d) shared; cf2xi-of-Popen4Xi-shared-by-wait-of-Popen4Xi-Windows: constant_forking4xi.ConstantForking4Xi object at 0x02B7F910; time: 17:20:51 03/30/10 FLE Daylight Time}
ξ {(Step 1/7e) sharing; dispatch-sharing-by-forkingpickler2xi-of-ForkingPickler4Xi: {class 'bytes': function save_bytes at 0x02B11DF8, class 'float': function save_float at 0x02B11DB0 ...

March 29, 2010
ξ upgraded test_finalize4xi.py and solved in finalize4xi.py key-problem so that class Finalize4Xi uses class variables _registry = {} and _counter = itertools.count() instead of finalizer4xi.py services
ξ however:
ξ { Queue4Xi : _feed ; (Step 8/9r) informing; Ignore-informing-by-feed-of-Queue4Xi: because of running in a daemon the thread, resources it uses may become unusable while the process is cleaning up! ; time: 20:18:21 03/29/10 FLE Daylight Time}
ξ perhaps to be solved in test_pipe1_mp_xi4.txt:
ξ # { Queue4Xi : _feed ; (Step 8/9q) warned; possible-IndexError-warned-by-feed-of-Queue4Xi: ** ** ; time: 15:39:38 03/29/10 FLE Daylight Time}
ξ explored reason and ace phases of test_pipe1_mp_xi4.py
ξ PROGRESS WITH TEST_PIPE1_MP_XI4.PY: SENSE PHASE PASSED WHEN PROCESS WAS RUN AFTER ACTIVATION !!!
ξ explored ForkingPickler4Xi trying to get rid off hit exceptions:
ξ it is ForkingPickler4Xi __init__ which sets: self.bin = protocol >= 1 and thereby if self.bin tests !
ξ to be analyzed whether saving dictionary should be done with different protocol !?
ξ message2print = "{(Step 5/7) set" + "; bin-set-by-init-of-ForkingPickler4Xi to: " + str(self.bin) + "; time: " + time4xi() + "}"
ξ print4xi(class2print, method2print, message2print)
ξ #HW: True
ξ got hello_world4xi to print text with standard, Dragon2Xi and Dragon4Xi systems
ξ tuned other programs such as popen4xi to minimize setting up constant objects by using class variables using ace-hello-world4xi.xml and reason-hello-world4xi.xml

March 28, 2010

analyzed hello_world4xi.py and concluded that
ξ 1. TARGET FUNCTION F4XI GETS EXECUTED ONLY AFTER HAVING CALLED RUN-METHOD OF PROCESS4XI
ξ 2. BOOT INCLUDES START
ξ 3. if you try to start afte boot the system recognizes it and does not allow starting a process twice !
ξ 4. popen4xi requires more analysis
ξ 5. process4xi requires more analysis
ξ 6. subprocess4xi requires more analysis; timeout can not NOT be ok - should it be 0 ?
ξ 7. upgraded all constant modules with tags and small characters to help testing, fixed some pickle2x4xi.py bugs
ξ # (Step 3/3) of hello world from Dragon4Xi Multiprocessing4xi!
ξ # { Process4Xi : run ; Step (1/2a) calling; target-of-process2xi-calling-by-run-of-Process4Xi: ; time: 20:00:02 03/28/10 FLE Daylight Time}
ξ # (Step 3/3) of hello world from Dragon4Xi Multiprocessing4xi!

analyzed test_pipe1_mp_xi4.txt and concluded the following about Process4Xi : __repr__:
ξ 1. it sets process status to stopped if wait-of-Popen4Xi-Windows returns 0
ξ 2. it gets integer type of process status from Popen4Xi wait method
ξ analyzed Popen4Xi poll method and deducted it calls Popen4Xi wait method
ξ analyzed Popen4Xi wait method:
ξ 1. milliseconds-passing-to-subprocess-WaitForSingleObject-by-wait-of-Popen4Xi-Windows = 800 ms whereas with Hello World4Xi 1000 ms !
ξ 2. res-got-by-wait-of-Popen4Xi-Windows = 0 whereas 258 with Hello World4Xi

decided:
ξ 1. increased timeout
ξ 2. created while loop to try several times
ξ message2print = "{(Step 3/7b) passing" + "; milliseconds-passing-to-subprocess-WaitForSingleObject-by-wait-of-Popen4Xi-Windows: " + str(msecs) + "; time: " + time4xi() + "}"
ξ print4xi(class2print, method2print, message2print)
ξ 800 ... 9800 which can NOT be true because test returns faster .i.e. subprocess LIES !!!

ξ # Process4Xi : __repr__ ; (Step 2/3b) set; status-set-by-repr-of-Process4Xi to: stopped;
ξ # (5/7) Popen4Xi2test wait {(Step 7/7) returning; returncode-of-popen2xi-returning-by-wait-of-Popen4Xi-Windows: 0; time: 17:06:58 03/28/10 FLE Daylight Time}
ξ #{ Popen4Xi : wait ; (Step 7/7) returning; returncode-of-popen2xi-returning-by-wait-of-Popen4Xi-Windows: 0; time: 17:06:58 03/28/10 FLE Daylight Time}

ξ # if self._popen.poll() is not None: <--
ξ # status = self.exitcode
ξ # (5/7) Process4Xi2test __repr__ {(Step 1/3d) set; status-set-by-repr-of-Process4Xi to: 0; time: 17:06:58 03/28/10 FLE Daylight Time} <-- HERE STATUS 0

ξ # (3/7) message: {(Step 2/3a) decided; type-status--decided-by-repr-of-Process4Xi: ; time: 17:06:58 03/28/10 FLE Daylight Time}
ξ #{ get_stopped_process4xi : get_stopped_process4xi ; started; get-stopped-process4xi-started: ; time: 17:06:58 03/28/10 FLE Daylight Time}
ξ # (3/7) message: {returning; stopped-process4xi-returning-by-get-stopped-process4xi: stopped; time: 17:06:58 03/28/10 FLE Daylight Time} !!!
ξ # { Popen4Xi : poll ; (Step 2/2b) returning; wait-function-of-popen2xi-returning-by-poll-of-Popen4Xi-Windows: >; time: 17:06:58 03/28/10 FLE Daylight Time}
ξ # { Popen4Xi : wait ; (Step 3/7c) calling; subprocess-WaitForSingleObject-calling-by-wait-of-Popen4Xi-Windows: ; time: 17:06:58 03/28/10 FLE Daylight Time}

ξ kept test_sharedctypes4xi.py as the model for the rest of test programs to be edited!

March 25, 2010
ξ streamlined all test programs to use similar patterns creating XML trace, trying and printing in capital
ξ fixed some smaller bugs with test programs
ξ upgraded Studio by tagging programs and creating find4txt.py to check ALL text files after tests
ξ run find4xi.py in Studio4Xi to find errors for print4xi.py !
ξ rerun ALL tests with debug_print4xi = True to see if there are any errors
ξ
ξ re-tagged constant_process4xi.py because it caused errors for print4xi.py and for test_value_proxy4xi.py !
ξ started to review and upgrade test programs, test_public_methods.py act as the best model to other so far!

March 24, 2010
ξ started to review and upgrade test programs
ξ
Explored test_proxy_mp_xi4:
initialized; ADDRESS-MANAGER4XI-initialized-by-init-address-manager4xi to:
ξ \\.\pipe\pyc-5012-0-seza0a; \\.\pipe\pyc-5012-0-qeefgf; \\.\pipe\pyc-5012-0-mezhpm;
ξ \\.\pipe\pyc-5012-0-ijv_7t; \\.\pipe\pyc-5012-0-qsoepz; \\.\pipe\pyc-5012-0-pugynj;
ξ \\.\pipe\pyc-5012-0-suchx3; \\.\pipe\pyc-5012-0-ijy18f; \\.\pipe\pyc-5012-0-xykxjr
ξ there is a bug in the system because there might be several managers rinning at the same time !!!
ξ three managers are created by test; why nine manager addresses are being set up ?
ξ SyncManager4Xi : _create ; (Step 3/5a) passing; address-of-syncmanager2xi-passing-to-Client-of-syncmanager2xi-by-create-of-SyncManager4Xi: None <-- BUG ***
ξ
ξ managers.py; BaseManager; start:
ξ # pipe over which we will retrieve address of server
ξ reader, writer = connection.Pipe(duplex=False)
ξ self._address = reader.recv() <-- here if receiving succeeds
ξ (Step 9/12) TO BE SOLVED: THIS MUST SUCCEED BECAUSE SELF._ADDRESS IS GIVE TO SELF._CLIENT = CLIENT4XI AS PARAMETER !!!
ξ { get_stopped_process4xi : get_stopped_process4xi ; returning; STOPPED-PROCESS4XI: stopped} <-- how does a process get stopped - see hello_world4xi!!!
ξ
ξ Conclusion: you have to start the process after you create it - however it might get started somewhere!
ξ
ξ self._process = Process4Xi( # Note: you HAVE to give this kind of self.x parameters
ξ target=type(self)._run_server, # target function is the method _run_server - but why type ?
ξ args=(self._registry, self._address, self._authkey, # self_address to be solved
ξ self._serializer, writer2xi), # writer2xi handle received from Pipe4Xi
ξ )
ξ (STEP 1/3a) OF HELLO_WORLD4XI MAIN: STANDARD MULTIPROCESSING STARTED
ξ (STEP 1/3b) CREATED PROCESS:
ξ (STEP 1/3d) OF HELLO_WORLD4XI MAIN: ALIVE STATUS AFTER CREATION: False
ξ (STEP 1/e) OF HELLO_WORLD4XI MAIN: ALIVE STATUS AFTER START: True
ξ (STEP 1/f) OF HELLO_WORLD4XI MAIN: ALIVE STATUS AFTER TERMINATE: True
ξ
ξ continue assert review in ALL modules and change to accepted !
ξ reviewed and updated modules with assert such as applyresult4xi.py and used ack4manoeuvres of class statistics for sensing
ξ created accept-verb to replace asserted messages
ξ modified returns by value2return so that there is only ONE return point in modules!
ξ embedded some functions and a class inside constant_managers4xi.py to get the system compiled !
ξ lesson: every time you edit a module, compile it immediatelly, compile all starting with the same alphabet, and compile all before tests !

March 23, 2010

ξ embedded some functions and a class inside constant_managers4xi.py to get the system compiled !
ξ HIT THE SEROUS PROBLEM WHICH SHOULD BE AVOIDED - EVERYTHING WAS DONE TO AVOID IT - BUT MODULES WOULD NOT GET COMPILED !!!
ξ M1/G12 test_baselistproxy4xi to be solved: autoporxy4xi.py-line 148; upgdrade test to provide XML
ξ explored test_proxy_mp_xi4.py
ξ to be solved M1/G12 BaseListProxy; Listener4Xi object has no attribute address
ξ test_dispatch4xi M3/G2 Dispatch; Listener4Xi object has no attribute address
ξ found missed class variables such as address = property(lambda self: self._address) in BaseManager4Xi
ξ decided to check ALL class variables
ξ init-of-Popen4Xi-Windows; prep_data2xi = get_preparation_data4xi(process_obj._name) <-- get dictionary and passes to be dumped ok !
ξ moved Syncmanager4Xi constant objects to class varibles and __init__ still worked; idea was to make those object available in all methods and perhaps from outside
ξ tagged __init__.py as last one to be tagged
ξ programmed find4txt.py to Studio4Xi to find in which test runs a module is used
ξ explored address and discovered that address can point to a temperary files used for pipe mechanism
ξ { arbitrary_address4xi : arbitrary_address4xi ; (Step 5/6) returning; tempfile2xi-returning-by-arbitrary-address4xi: \\.\pipe\pyc-1836-0-kbrs9o; time: 10:57:35 03/23/10 FLE Standard Time}
ξ { Pipe4Xi : Pipe4Xi ; (Step 2/8c) set; address2xi-set-by-Pipe4Xi to: \\.\pipe\pyc-1836-0-kbrs9o; time: 10:57:35 03/23/10 FLE Standard Time}
ξ made sure authkey get a value even if passed as None
ξ explored bytes and authkey:
ξ byte2xi = b'yourDragonXi'; if isinstance(byte2xi, bytes): <-- is TRUE i.e. becomes an instance of class bytes !
ξ b2xi = Bytes4Xi(); class Bytes4Xi(bytes):, def __init__(self):, if isinstance(b2xi, bytes): <-- TRUE i.e. becomes an instance of class bytes via inheritance
ξ print(type(byte2xi)) <-- whereas print(type(b2xi)) <-- class __main__.Bytes4Xi
ξ authkey = os.urandom(32); if isinstance(authkey, bytes): <-- is TRUE i.e. becomes an instance of class bytes !

March 22, 2010

ξ REVIEW OF ALL MODULES DONE!
ξ completed _*4xi.p?
ξ utilized ack2x/nack2xi strategy in loops as follows after the loop:
ξ if nack2close is True:
ξ message2print = "{warned" + "; nack2close-warned-by-close-cache4xi: " + " ** " + str(nack2close) + " ** " + "; time: " + time4xi() + "}"
ξ print4xi(class2print, method2print, message2print)
ξ else
ξ message2print = "{operated" + "; ack2close-operated-by-close-cache4xi: " + str(ack2close) + "; time: " + time4xi() + "}"
ξ print4xi(class2print, method2print, message2print)
ξ improved ack4x handling by adding also nack2x to help analysing trace - ack and nack are nouns of their own
ξ trace in while-loops must be limited

March 20, 2010

ξ started _*4xi.p?
ξ completed t*4xi.p?, u*4xi.p?, v*4xi.p?, x*4xi.p?, y*4xi.p?, w*4xi.p?
ξ renamed xml noun obj to object in all modules; giving own names instead of changing the original code is much safer and also makes tracing easier with understable nouns
ξ examined persistent_id :
ξ { ForkingPickler4Xi : persistent_id ; passed; obj-passed-to-persistent-id-of-ForkingPickler4Xi: ; time: 09:26:47 03/20/10 FLE Standard Time}
ξ
ξ changed self._authkey = str(os.urandom(32)) to self._authkey = os.urandom(32) in mainprocess4xi.py;
ξ explored byte and /test/test_bytes.py

March 17, 2010

ξ saved and took back-ups because changing authorization key handling in the system ia a major change !
ξ found one hot in reason-hello-world4xi.xml: >{(Step 3/9f) hit; function-hit-by-save-of-ForkingPickler4Xi: *** function save_dict at 0x02AC9930 *** ; time: 11:15:25 03/18/10 FLE Standard Time
ξ # to be solved - why does it try to write an empty dictionary for above dictionary <-- because it finds that character is authkey string !!!
ξ # authkey suspected:
ξ #HW2: { 'authkey': "b'\\xcb\\xb9\\x96\\x8by\\xffE\\x9a\\xa8\\x9c\\xf0\\xcf\\xd5\\x99\\xc6\\xba\\xf2\\x812FQ\\xb1[\\x84\\xf1t\\x84\\x85\\xed\\x9c\\xd9?'",
ξ
ξ #HW1: { 'authkey': 'b"g~\\xd2\\xfc\\xcc\\xe6v_\\xc2\\x1d\\xa3\\xb6\\x08O\\xda\\xdaj\\x83T\\xe4\\xea\\x8fr]CG}w\\xa5\\xb6\\xc6\ '"',
ξ viewed and upgraded dummyprocess4xi.py which is used by ThreadPool4Xi class and which simulated multiprocessing with thread in a single core system
ξ created test_dummy_process4xi.py, which can be used as a model for other test programs

March 17, 2010

ξ spent 24 HOURS to review and edit _Unpickler class embedded inside forkingpickler4xi.py module - original pickle.py is TOO BIG !
ξ added try and yield-blocks with ack4x variables to make sure operations has a good chance to succeed and all possible trials are being made

March 16, 2010

ξ ACHIEVED HELLO_WORLD4XI.PY WITHOUT NO ERRORS
ξ PICKLING IS NOW MUCH BETTER!
ξ compared to pickle.py in /Python3.3./lib and found following to miss: _tuplesize2code = [EMPTY_TUPLE, TUPLE1, TUPLE2, TUPLE3]
ξ save-tuple-of-ForkingPickler4Xi and the loop for element in obj fails - to be solved !!!!
ξ reviewed in ALL modules -passing-to- to delete bugs where a parameter with = has been used in trace !!!
ξ example bug in forkingpickler4xi.py:
ξ message2print = "{passing" + "; level-passing-to-import-by-save-global-of-ForkingPickler4Xi: " + str(level) + "; time: " + time4xi() + "}"
ξ __import__(module, level=0)

corrected to:
ξ message2print = "{passing" + "; level-passing-to-import-by-save-global-of-ForkingPickler4Xi: " + str(0) + "; time: " + time4xi() + "}"

ξ deleted all + str(* in all modules i.e. do NOT try to trace pointers !
ξ learned again hard way how dangerous str-function is: give a non existing value (Python does NOT check!) and it TILTS!
ξ suspected: message2print = "{(Step 9/9a3) passing" + "; rv2xi-pointer--passing-to-save-reduce-by-save-of-ForkingPickler4Xi: " + str(*rv2xi) + "; time: " + time4xi() + "}"
ξ TILTS after:
ξ message2print = "{(Step 9/9a2) passing" + "; obj-passing-to-save-reduce-by-save-of-ForkingPickler4Xi: " + str(obj) + "; time: " + time4xi() + "}"
ξ solve why the next fails with second object for ForkingPickler dump function !
ξ message2print = "{performed" + "; save-performed-by-dump-of-ForkingPickler4Xi: " + str(self.save) + "; time: " + time4xi() + "}"
ξ print4xi(class2print, method2print, message2print)
ξ #HW 1. : bound method ForkingPickler4Xi.save of forkingpickler4xi.ForkingPickler4Xi object at 0x02BCE250
ξ SOLVE the second dump in popen4xi.py:
ξ { Popen4Xi : __init__ ; (Step 7/8p) hit; exception-hit-by-init-of-Popen4Xi-Windows: *** function: process_obj: to_child2xi: <_io.BufferedWriter name=4> HIGHEST_PROTOCOL: 3 *** ; time: 00:16:55 03/16/10 FLE Standard Time}
ξ had to add embedded functions of popen4xi.py to print4xi.py and to pickle2x.py functions to get them traced!
ξ lost PyPE - due to Vista or virus !?

March 15, 2010
ξ checked inheriting/inherited messages in ALL modules
ξ dump4xi.py should NOT be used but instead dump-function embedded inside popen4xi.py !
ξ had to turn debug_print4xi to True
ξ MET SEVERAL FATAL PROBLEMS:
ξ adding inheriting/inherited messages had created several bugs to modules !!!!
ξ *** BUG *** message2print = "{(Step 1/7e) inheriting" + "; Pickler-inheriting-by-forkingpickler2xi-of-ForkingPickler4Xi: " + str(ForkingPickler4Xi.Pickler) + "; time: " + time4xi() + "}"
ξ { ForkingPickler4Xi : __init__ ; (Step 1/7d) borning; forkingpickler2xi-of-ForkingPickler4Xi-borning: 22:37:42 03/15/10 FLE Standard Time}
ξ (1/7) class: Popen4Xi
ξ (2/7) method: __init__
ξ (3/7) message: {(Step 7/8i) hit; exception-hit-by-init-of-Popen4Xi-Windows: *** function: prep_data2xi: {'authkey': "b'\\xe94D\\xe6\\x06`\\xf1\\xe5\\xf3\\x19\\xe5\\x1b\\xd5a\\xa6\\x982@\\xc0W\\xbd\\xca\\x9aY[^\\x8a\\xcf\\xd9\\xc6\\x90`'", 'sys_path': ['e:\\Sw4Xi\\Python31\\Lib\\multiprocessing4xi', 'c:\\sw\\Python31', 'C:\\Windows\\system32\\python31.zip', 'c:\\sw\\Python31\\DLLs', 'c:\\sw\\Python31\\lib', 'c:\\sw\\Python31\\lib\\plat-win', 'c:\\sw\\Python31\\lib\\site-packages'], 'name': 'Process4Xi-1', 'orig_dir': 'e:\\Sw4Xi\\Python31\\Lib\\multiprocessing4xi', 'sys_argv': ['hello_world4xi.py'], 'main_path': 'e:\\Sw4Xi\\Python31\\Lib\\multiprocessing4xi\\hello_world4xi.py', 'log_to_stderr': True} to_child2xi: <_io.BufferedWriter name=4>HIGHEST_PROTOCOL: 3 *** ; time: 22:37:42 03/15/10 FLE Standard Time}
ξ (4/7) keyclass2xi: Popen4Xi2test
1. ForkinPickler method dump does NOT get called !
2. print4xi fails with above and with dump4xi !
3. dump has previously worked with hello_world4xi.py !!!

ξ solved OS error 9: bad file descriptor with os.close in Popen4Xi __init__ by calling close4xi instead of os.close to close rhandle2xi
ξ got test_server_mp_xi4.py to start server - unresolved why trace is missing and what should happen !?
ξ ADD SLEEP WHERE YOU HAVE TO RECEIVE OTHERWISE ADDDRESS BECOMES NONE - AND TUNE TIMEOUT !!!

March 12, 2010
ξ discovered that the base software is too much built on assert and events such as message sending and receive succeed !!
ξ ADD SLEEP WHERE YOU HAVE TO RECEIVE OTHERWISE ADDDRESS BECOMES NONE - AND TUNE TIMEOUT !!!
ξ 1) answer_challen4xi.py 2) applyresult4xi.py
ξ continued Server4Xi
ξ tuned Popen timings
ξ discovered how bad idea it is to use Python =None parameter passing - caller should always give some value or callableshould force some value !

March 12, 2010
ξ stopped to fallback_getvalue of Server4Xi which TOO BIG AS ONE MODULE !!!!

March 11, 2010

ξ SYNCMANAGER4XI, START METHOD BUG IN DICT
ξ checked all modules with ξ DICTPROXY4XI BUG FOUND, COMMA MISSING CAUSING A METHOD NAMED VALUESSENSE !
ξ address None get passed by SyncManager _create when test_proxy_mp_xi4.py tries to create dictionary with manager Step 5/12
ξ test_proxy_mp_xi4.py STILL THE SAME FATAL ERROR TO BE SOLVED !!!
ξ SyncManager4Xi : _create ; (Step 2/5c) asserted; state-value-of-syncmanager2xi-asserted-by-create-of-SyncManager4Xi: 1; time: 16:58:17 03/11/10 FLE Standard Time}
ξ Client4Xi : Client4Xi ; (Step 1/6a) started; Client4Xi-started: ; time: 16:58:17 03/11/10 FLE Standard Time}
ξ Client4Xi : Client4Xi ; (Step 1/6b) passed; address-passed-to-Client4Xi: None <--- *** FATAL ERROR ***

ξ continuing S!
ξ programmed omega2sleep4xi function into sleep4xi to give time to others in systematic way; used in SocketClient4Xi
ξ investigate where and how those to be picked are being registered !!!
ξ solve from_address in BaseManager __reduce__
ξ solve address None
ξ solve why authkey is not byte string !!!

March 10, 2010

ξ starting to review S with connection.py
ξ reviewed S with shared_ctypes.py
ξ hit the fact that modularization forced to rename functions such as synchronized to synchronized_function4xi
ξ hit the fact that modularization forced to rename classes

ξ

March 9, 2010

ξ added register4xi-tag both to programmer profile and for developer macros - with goal to find module level settings
ξ module level code poses challenges in old modules: for example registering to ForkingPickler4Xi at module level conditionally as is reduce_pipe_connection4xi.py!
ξ discovered various ways in use for splitting modules to smaller ones you have to take operating system into account
ξ original big modules define different functions based on OS; see reduction.py
ξ the alternative is to test OS inside a function - this also used in original one sometimes
ξ started R

March 5, 2010

ξ corrected some bugs; found better NOT to include try to import statements- CORRECT BACK TO ALL ASAP!!!
ξ deleted str(self) in ALL modules
ξ started to examine server and pickle-usage!

March 4, 2010

ξ concluded; NEW COMPILER AND NEW PROCESSOR ARE NEEDED - WITH DEVELOPMENT TOOLS!
ξ concluded; new language can be built partly based on verbs used for dragonized modules!
ξ concluded; Python is NOT for sense-reaso-ace-metaphore!
ξ concluded; Python is NOT for autonomous and unmanned systems!
ξ completed queue4xi.py and thereby q*4xi.py
ξ completed p*4xi.py
ξ converted test*2xi.py to test*4xi.py and corrected some bug found in new tests
ξ created profile Utility Tester and update profile Commander4Xi to contain more critical tests
ξ created finalize verb to handle finally-cases
ξ started to add return statement where it is missing
ξ solve why get of Queue4Xi always returns None !?
ξ realized Python is NOT suitable for unmanned and autonomous systems - not are NONE of existinf programming languages !
ξ UAS languages should have more verbs and be more tolerant to exceptions and possible errors !
ξ made sure all timout are handled by timeout4xi.py
ξ started the strategy to remove raise and to add verified and similar messages to return phase, see assert_spawning4xi.py

March 3, 2010

ξ achieved progress with Queue - put seems to work
ξ replaced one raise in Queue4Xi put for queue full situation with warning and got it to work !!!
ξ analyzed and upgraded Queueu4Xi !
ξ smoke out assertions asap !!!
ξ completed concentaring all timeouts to timout4xi.py and REMEMBER to take backups !
ξ analyzed class2print = 'ApplyResult4Xi'; method2print = 'get' with G11/G16 Math2 MP Xi4 Test
ξ programmed to test_math_mp_xi2.py the function set_trace, which uses the same subfunctions as pickle4xi.py - this makes it easier to mark tracing !!!
ξ added to ack4manoeuvres and nack4manoeuvres to applyresult4xi class to calculate manoeuvres in __init__
ξ unresolved how ApplyResult4Xi caller fails to get all variables which __init__ of ApplyResult4Xi initializes ?????????????????

March 2, 2010

ξ programmed timout4xi.py to give a proper timeout for a class/function and method/function
ξ aced print4xi parameters as follows: timeout = omega2timeout4xi(class2print, method2print)
ξ programmed find4share.py into Studio to trace class variables and their usage
ξ study server2xi = cls._Server(registry, address, authkey, serializer)
ξ review class variable usages to old modules
ξ marking status review to ALL CLASS VARIABLES

March 1, 2010

ξ developed share4xi-macro; share-verb can be used by __init__of classes to tell what class variables they are sharing
ξ developed pickle4xi-macro and updated pickle4xi.p?
ξ creates threreby less define-macro im programs
ξ reviewing share4xi-macros i.e. ALL CLASS VARIABLES such as _address_to_local = {}; _mutex = ForkAwareThreadLock4Xi() of BaseProxy4Xi AND references the dragonized class BaseProxy4Xi , NOT old one such as BaseProxy
ξ added sharing-verb into __init__ of classes
ξ added shared-verb into modules using shared class variables
ξ _address_to_local bug found in baseproxy4xi.py: BaseProxy._address_to_local[token.address] = tls_idset
ξ _mutex = ForkAwareThreadLock4Xi() corrected to BaseProxy4Xi class variables; careful
ξ added more verbs to knowledgebase and upgraded illegal verb messages of print4xi.py

February 28, 2010

ξ review define4xi
ξ develop macro for class variables, update it and review how variables are being used in system !
ξ update verb2?4xi.p?
ξ define macro for class variables - use define4xi in other definitions - a macro4xi should be specific !
ξ add pickle verb
ξ must REVIEW ALL CLASS VARIABLES such as _address_to_local = {}; _mutex = ForkAwareThreadLock4Xi() of BaseProxy4Xi AND references the dragonized class BaseProxy4Xi , NOT old one such as BaseProxy
ξ mark status review to ALL CLASS VARIABLES
ξ _address_to_local bug found in baseproxy4xi.py: BaseProxy._address_to_local[token.address] = tls_idset
ξ _mutex = ForkAwareThreadLock4Xi() corrected to BaseProxy4Xi class variables; careful
ξ added more verbs to knowledgebase and upgraded illegal verb messages of print4xi.py

February 27, 2010

ξ upgraded test_pool1_mp_xi4.py to be more flexible and to skip test phases to end the test in any case
ξ completed pool4xi.py
ξ realized the weakness of used assert-staments and decided to replace assert-statements with if-staments back-ed up by warning or hot-message
ξ created profile Assistant Studio for G11/G19 keyboard
ξ added measure-verb to print measured unit such as acks for operations such as successful joining of pool
ξ continue join in pool4xi.py
ξ solve why address None got passed in connections - Client might be the problem!!!
ξ why Process4Xi : __repr__ ; (Step 2/3b) set; status-set-by-repr-of-Process4Xi to: stopped
ξ correct timeout None; tune timeouts in o.2-0.8 seconds to time4xi.py to solve the problem that if Queue4Xi get does not get timeout but None, it will loop forever !!!
ξ check G17 = test_pool1_mp_xi4.py
ξ continue rest of p*4xi.p?
ξ test and review ace-current-process4xi.xml

February 25, 2010

ξ address None got passed in connections - Client might be the problem!!!
ξ hit the problem Process4Xi : __repr__ ; (Step 2/3b) set; status-set-by-repr-of-Process4Xi to: stopped
ξ hit the problem that if Queue4Xi get does not get timeout but None, it will loop forever !!!
ξ completed and moduletested pipe4xi.py; hello_pipe4xi.py OK and test_pipe1_mp_xi4.py fails due to queue
ξ upgraded test_pipe1_mp_xi4.py
ξ check G17 = test_pool1_mp_xi4.py
ξ continue p*4xi.p?

February 24, 2010

ξ viewed performance monitor in G17 keyboard and FOUR CORES DOING AT THE SAME TIME !!!
ξ completed pickle4xi.py; it pickled ALL classes and ALL functions in the multiprocessing4xi folder!
ξ created modules pickle2a4xi.py ... pickle2_4xi.py
ξ completed test_pickle4xi.py - in future it could be updated to show object status, if required
ξ created link4xi-tag to help developing process because Python does NOT provide linking and compiler is unreliable !
ξ considered adding link-data, however taking into account modules already have -passing-to-information; concluded not needed!

February 23, 2010

ξ noticed special case (?) _exposed_ = ('__getattribute__', '__setattr__', '__delattr__') in NamespaceProxy !!!
ξ completed n*4xi.p? and o*4xi.p?
ξ embedded _ functions and mainprocess4xi.py into current_process4xi.py !

February 22, 2010

ξ hit by Python bug; Python does NOT try all import statements buts goes to exception once meets the first one !
ξ replaces assert statements with try-except blocks
ξ decided to try moving _current_process to mainprocess4xi.py !
ξ continue with m*4xi.p?
ξ took away self in activated messages of all methods!
ξ let compiler to initialize all constant values; seems to be mandatory to get them work in system tests!

February 20, 2010

ξ proceeded in math test; pool4xi.py and learned: take way self in method trace messages activated !!!!
ξ completed l*4xi.py ; SEMAPHORE needed detailed analysis !
ξ edited __init__ methods and tried to get a value to each self-variable !

February 17, 2010

ξ completed kskeleton4xi.py and created test_kskeleton4xi.py
ξ completed j*4xi.p?; joinablequeue4xi.py
ξ created step; stepped; stepping verbs, macros and implemented in joinablequeue4xi.py - offers step trace, if required

February 16, 2010

ξ completed i*4xi.p?
ξ added try-except block to standard, multiprocessing and dragonxi imports; this makes software more flexible to get compiled !

February 15, 2010

ξ adding inheriting and inherited pair to __init__ (if exists) of classes AND to sense method (always exists!)
ξ completed f*4xi.p? and h*4xi.p?, where heap4xi.py found too large to review at once!

February 13, 2010

ξ updated profile information to some modules
ξ tagged and tested format4xi.py
ξ updated Studio4Xi programs find4py, find4xi and macro4xi to use relative path, which makes them usable in other PCs !
ξ installed PyPE 2.9 as third editor and found it very useful with crimson and notepad

February 10, 2010

ξ aced xml-files to module test programs such as forkingpickler4xi.py - a really useful ASSET for developers!
ξ completed forkingpickler4xi.py; a HUGE modules with MANY embedded functions and even classes !
ξ utilized ace-hello-world4xi.xml to embed values to modules such as forkingpickler4xi.py
ξ found out that programmers do want Python compiler to continue processing in a module after function - this makes programs difficult !

February 9, 2010
ξ popen4xitest_server_mp_xi4.py: ImportError: No module named popen4xi - see mainprocess4xi.py !?
ξ completed c*4Xi.p?
ξ utilized aced XML data to monitor data values; filters information from data and is useful
ξ hit again by fatal feature in Python: id does NOT check calls so import statements must be perfect !
ξ added from _multiprocessing import win32 to corresponding modules
ξ deleted debug_info
ξ deleted sub_debug
ξ deleted info; from info4xi import info4xi
ξ deleted warning

February 8, 2010
ξ hatch-verb
ξ fly-verb
ξ protect4xi for copyright
ξ take-off-verb
ξ rotate
ξ created zombie2xi to track the success of a method
ξ systematically checked *2xi = and then replaced; once 2xi-variable set, it SHOULD be used by the module !
ξ duplicate calls replaced with duplicate4xi; Python does NOT check functions called !!!

February 6, 2010
ξ reviewed a*4xi.py and developed checklist for review
ξ replaced self with object name in all classes
ξ completed _t*4xi.py .i.e THE WHOLE SOFTWARE

February 4, 2010
ξ learned to compare public API to print4xi.py - otherwise trace causes problems !
ξ solved _cache4xi usage; see reduction.py: supports for a per-process server thread which caches pickled handles
ξ system software has several _cache variables; some named ok, others like _cache not; therfore _cache4xi is GOOD !
ξ continuewd with ?4xi.p_
ξ corrected bug in finalizer4xi.py; passed a wrong parameter to print4xi.py
ξ consider giving priority and/or difficulty level to test programs to sort tests to some order to help test phase !!
ξ 62 test programs to be tagged !!!

February 3, 2010
ξ implemented the following tags for test programsusing verbs verify and contextualize:
ξ #
ξ # -------------------------------------------------------------------------------------------------
ξ #
ξ #
ξ #
ξ # -------------------------------------------------------------------------------------------------
ξ brainstorming how to make test programs more machine readable to produce information for testing
ξ target4xi/verify4xi/-tag might be good to show modules being tested by the test module - abstract4xi is NOt good and is already used for different purposes!
ξ does NOT provide any information - maybe link4xi-tag or similar to give more info ?

February 2, 2010
ξ update: test_math2_mp_xi4; test_pool1_mp_xi4; test_processref_mp_xi4; test_server_mp_xi4 !
ξ compare test*2xi to test*4xi; check 4xi has all 2xi and if not create necessary test programs !

February 2, 2010
ξ updated test_ctypes_mp_xi4.py to the new structure with try-except and ack-variables to ge the XML-trace whatever happens during the test!
ξ took into use steps to make it easy to find how test went:
ξ print("(\n (test_ctypes_mp_xi4 Step 1/12a) TRIAL: creating multiprocessing queues for sensing, reasoning and acing !")
ξ print("(\n (test_ctypes_mp_xi4 Step 1/12b) ACK: created multiprocessing queues for sensing, reasoning and acing !")
ξ print("(\n (test_ctypes_mp_xi4 Step 1/12c) NACK: *** failed to create multiprocessing queues for sensing, reasoning and acing ***")
ξ if ack2process is True:
ξ try:
...
ξ tagged worker4xi.py

February 1, 2010
ξ run find4xi.py to check possible message usage errors - find few and having detailed info in corresponding text messages files helped to correct bugs quickly !
ξ tagged v*4xi.py which includes all verb modules
ξ realized that a class variable definition might be in the middle of class code; example: value = property(get, set) in Value4Xi class !
ξ tagged u*4xi.py i.e. uskeleton4xi.py and created test_uskeleton4xi.py which bot can be used to create new modules and test programs for them

January 31, 2010
ξ inserted try-finally structure in tests to get trace files for analysis
ξ created XML output for test programs
ξ tagged all test programs and at the same time standardized test program structures

January 30, 2010
ξ decided to CHANGE ASAP class method start messages so that they do NOT try to print self !!!!!
ξ decided to use profile 11 for test programs
ξ completed tagging test programs. due to self printing in methods problems arised !

January 28, 2010
ξ discovered how Python naming conventions makes it difficult to understand and follow program logic
ξ tagged syncmanager4xi.py - huh huh huh !!!
ξ self._Listener, self._Client = listener_client4xi[serializer] <-- _Listener and _Client
ξ message2print = "{(Step 12/14a) set" + "; Listener-of-syncmanager2xi-set-by-init-of-SyncManager4Xi to: " + str(self._Listener) + "; time: " + time4xi() + "}"
ξ
ξ tagged constant_managers4xi.py with 33 constants which was a huge task; combination of smart keyboards, macros and systematic approach helped
ξ definetely there has to be another way to handle constants in the system by automatically managing init, get and set operations !
ξ starting tagging ALL constant modules throughly because syncmanager4xi.py uses ALL of them !!!

January 27, 2010
ξ paying attension to data passed and passing and being used is worth doing because Python compiler does NOT check variable, data, objects being referred and used as it should !!!
ξ tuned tagging of constant_connection4xi.py and although it required a lot of work it pays !
ξ took into use the verb abbreviate as follows:
ξ message2print = "{(Step 1/15c) abbreviating" + "; connection-abbreviating-by-handle-request-of-Server4Xi: " + "c" + "; time: " + time4xi() + "}"
ξ message2print = "{(StepOriginal) passing" + "; connection-passing-to-Server-handle-request-by-handle-request-of-Server4Xi: " + str(c) + "; time: " + time4xi() + "}"
ξ completed server4xi.py module which is a HUGE and TOO bif a module even after having been dragonized !
ξ checked find4py.txt trace and correct StepOriginal NOW !

January 26, 2010
ξ started to tag server4xi.py
ξ updated and checked the modules called by server4xi
ξ compared dragonized code to that of multiprocessing one

January 25, 2010
ξ started s*4xi.p?
ξ edited (Step X/Y) headers to modules because step information in trace speeds up debugging
ξ created trace messages to all function data in all modules and abonded _param naming convention because trace shows in detail class and function ownership to data
ξ inserted borning, activate to all __init__ functions of classes
ξ systematically edited function, class and module tags

January 23, 2010
ξ continued tagging s*4xi.py

January 22, 2010
ξ tagged program level, started and state tags to s*4xi.py; tagged borning and activated - a good idea to tag one logical entity at a time in modules !

January 21, 2010
ξ tagged r*4xi.p? ; VERY many reduce-modules just passing variables and calling rebuild-modules which call multiprocessing modules - SEVERE AND HUGE LAYERING on top of multiprocessing and OS !!!
ξ tested hello_world4xi.py and documented current_process4xi.py and mainprocess4xi.py and process4xi.py
ξ examined current_process usage in the system; it is a function AND it is defined as global _current_process i.e. it is a smart object having methods such as ._counter

ξ MainProcess4Xi represents the current process:
ξ init_current_process4xi ; (Step 5/11) initialized; name-of-current-process-initialized-by-init-current-process4xi to: MainProcess4Xi ;time: 10:36:14 01/21/10 FLE Standard Time}
ξ #HW: { get_current_process4xi : get_current_process4xi ; returning; current-process-returning-by-get-current-process4xi: ; time: 10:36:14 01/21/10 FLE Standard Time}
ξ #HW: { MainProcess4Xi : __repr__ ; (Step 1/7) started; repr-of-MainProcess4Xi-started: 10:36:14 01/21/10 FLE Standard Time}
ξ #HW: { MainProcess4Xi : __repr__ ; (Step 7/7) returning; r2xi-returning-by-repr-of-MainProcess4X: ; time: 10:36:14 01/21/10 FLE Standard Time}

ξ realized that reduce verb means to set under control of multihtreading C-language package and therefore the name of the module does not reflect what the module is doing
ξ examined _tls ; tls = thread local storage; how could you guess this kind of naming !?
ξ All threads of a process share its virtual address space.
ξ The local variables of a function are unique to each thread that runs the function.
ξ However, the static and global variables are shared by all threads in the process.
ξ With thread local storage (TLS), you can provide unique data for each thread that the process can access using a global index.
ξ One thread allocates the index, which can be used by the other threads to retrieve the unique data associated with the index.
ξ -see find4py.txt; forking.py: _tls = _thread._local();class Popen(object): _tls = _thread._local()
ξ continue with RLock4Xi

January 20, 2010
ξ imported as standard to each module: import os, sys, threading, _thread for SENSE, REASON AND ACE - class modules with sense, reason and ace methods
ξ made sure that the verb state is in the knowledgebase of verbs as an allowed verb for trace messages and to parser4xi
ξ utilized find4py.py to check that all tagged modules have the new state4xi-tag
ξ changed the program level tag status4xi to state4xi because macros are designed to be based on verbs - not on nouns
ξ example: state4xi status = "ACK4tagging; ACK4test_constant_family4xi.py; NACK4systemtest
ξ considered game pad to provide the laptop with macro facilities
ξ create business concept to improve productivity of software engineering to factorize it in large scale to countries with cheap labour and to use internet
ξ concluded that tagging program level tags required programming knowledge and is critical to get modules compiled again after tagging process
ξ brainstormed that using two keyboards two persons could tag program modules one just pressing the macro key required/shouted by another person !
ξ profiling taqs for embedding into modules also forces one to embed those tags into modules which is very useful to get modules as standard as possible
ξ using keyboards such as G11 and G19 would make it easier to outsorce tagging

January 19, 2010
ξ completed q*4xi.py tagging i.e. queue4xi.py
ξ upgraded print4xi.py to print steps if print4xi.py is debugged
ξ edited some old trace messages with no time - thanks to feedback from print4xi.py
ξ
ξ upgraded modules with class to display their objects based on the new naming system
ξ checked with reason XML reason-hello-world4xi.xml verbs borning and activated contents - very useful feature to get these XML files generated automatically !
ξ XML nouns can be such as xxxxxxxx-of-popen2xi for varibles self.xxxxxxxx where popen2xi is the object of Popen4Xi
ξ backed-up before starting to tag queue4xi.py

January 18, 2010
ξ completed tagging p*4xi.p? and tested process4xi.py and pipe4xi.py with hello_world4xi.py and hello_pipe4xi.py
ξ improved tracing by differentiating methods with the same name:
ξ message2print = "{started" + "; name-property-of-Process4Xi-started: " + str(self) + "; time: " + time4xi() + "}"
ξ message2print = "{started" + "; name-setter-of-Process4Xi-started: " + str(self) + "; time: " + time4xi() + "}"

ξ tagged and tested init of Process4Xi
ξ decided to name Class objects to be able to better trace class objects among all objects
ξ old: message2print = "{(Step 3/15) set" + "; self._identity-set-by-init-of-Process4Xi to: " + str(self._identity) + "; time: " + time4xi() + "}"
ξ new: message2print = "{(Step 3/15) set" + "; identity-of-process2xi-set-by-init-of-Process4Xi to: " + str(self._identity) + "; time: " + time4xi() + "}"
ξ where identity-of-process2xi depicts the attribute identity of the process2xi instance for the class Process4Xi
ξ note that because identity starts the attribute name it makes it more unique in trace

January 14, 2010

ξ tagged print4xi.py which ANLY has program tags NOT messages
ξ tagged popen4xi.py
ξ tested certain methods of Popen4Xi and tuned some timings; new trace messages helped to find the trace message
ξ #hw: { dump : dump ; (Step 1/4a) started; dump-of-Popen4Xi-started: ; time: 20:31:30 01/13/10 FLE Standard Time}
ξ #hw: { Popen4Xi : __init__ ; (Step 0/8a) started; init-of-Popen4Xi-started: ...
ξ { Popen4Xi : __init__ ; (Step 0/8b) borning; object-of-Popen4Xi-borning: ...

ξ used program tags to document testing and tagging of popen4xi.py which is BIG because it handles different operating systems and is a core module
ξ example(edited suitable for this HTML file):
ξ #function4xi function = "dump-of-Popen4Xi" usage = "
ξ # (obj, file, protocol=None)
ξ #"
ξ #note4xi note = "Windows OS - tagged - HW and more testing needed"

January 13, 2010

ξ continue init Step 4/8 of popen4xi.py
ξ learned you can NOT trace passing if function require a certain parameter and it has not set before call but its value is given as a parameter
ξ upgraded test programs to print their identity and steps to differentiate from the trace produced by pint4xi for tested modules
ξ edited systematically the whole module popen4xi.py which is essential and VERY big partly because it takes into account different operating systems
ξ abondeded the idea to use -for-ZZZZZZZZ instead of -of-ZZZZZZZZ for a class ZZZZZZZZ with internal functions depict that the function is FOR the class and embedded inside the module
ξ pool4xi.py tagged and tests run
ξ pipe4xi, pipeclient4xi, pipelistener4xi tagged
ξ added xml trace to test_proxy_mp_xi4.py and hello_pipe4xi.py
ξ tagged test programs such as test_proxy_mp_xi4.py with program-profile tags
ξ print4xi.py handles OK bad messages by warning, not by stopping !!!

January 11, 2010

ξ updated test_proxy_mp_xi4.py to output sense/reason/ace -proxy-mp-test4xi.xml
ξ examined test_proxy_mp_xi4.txt
ξ run find4xi.py to see errors in trace messages; many because there were modules not updated to new message formats
ξ tagged pipe4xi.py !
ξ completed m*4xi.py such as manager4xi.py !
ξ checked tagged modules with find4py.py
ξ used find4py.py to find class module missing the folowing imports (Python compiler does NOT check imports):
ξ from ace_object4xi import ace_object4xi
ξ from reason_object4xi import reason_object4xi
ξ from sense_object4xi import sense_object4xi

January 9, 2010

ξ hit challenges with MainProcess4Xi.py; could NOT send self to trace !
ξ decided to keep started and activated messages with self and to watch with other modules - in most class modules passing str(self) seemed to work
ξ tagged MainProcess4Xi.py which is an essential module in multiprocessing
ξ continued with constant*4xi.py and added expose4xi-tag using module interface parameters for exposure content
ξ learned hard way that you do NOT change parameter names back to param even if you could differentiate param in trace !!!!
ξ update the macro expose4xi by changing its attribute as follows: expose4xi expose-of-Verb4Xi = changed to expose4xi exposure =
ξ reasoning that attribute must be the noun exposure and that this tag is used inside the class4xi tag

January 8, 2010

ξ utilized find4py.py of Studion4Xi to catch messages with missing information such as expose-of-ZZZZZZZZ
ξ finished with F, took all back-ups to hard disks and USB stick before going back to A to edit ALL messages in modules A to F
ξ passing verb indicate a call and therefore calling verb is not needed
ξ utilized tracing messages to differentiate when original classes are being used:
ξ message2print = "{performed" + "; Original-Listener-performed-by-init-of-Listener4Xi: " + str(Listener.__init__) + "; time: " + time4xi() + "}"
ξ print4xi(class2print, method2print, message2print)

ξ updated the profile of listener4xi.py to 03, because its class embeds a function !
ξ completed i*4xi.py, j*4xi.py,
ξ added missing borning and activate messages in __init__ of some classes (parser4xi.py will require and check these kind of errors)
ξ updated import4xi.py and import_classes4xi.py keeping the valuable history information (these modules only import)
ξ used the other editor to embed more rare messages such as append to modules
ξ discovered that renaming nouns makes trace more readable and offer possibility to use names NOT allowed by Python compiler

January 7, 2010

ξ completed i*4xi.py
ξ moved return traces to finally where appropriate
ξ printed trace BEFORE deleting
ξ used passing messages instead of trying where it suited better - after all a varible passed exists and can be displayed before trying a function

ξ completed f - forkingpickler4xi.py was the most difficult one
ξ detected object phases borning-activated using ace-hello-world4xi.xml; for example: object-of-ForkingPickler4Xi-borning and object-of-ForkingPickler4Xi-activated
ξ UNRESOLVED: how to avoid multiprocessing.process.AuthenticationString type in forkingpickler4xi.py !??
ξ tailored manually some messages getting their data from functions
ξ run get_preparation_data4xi.py both using original and dragonized multiprocessing

January 6, 2010

ξ xml trace shows class object states started, borning and activated, which helps debugging
ξ completed tagging forkingpickler4xi.py which is the most demanding and the most important module in multiprocessing !
ξ verfied hello_world4xi.py with the new forkingpickler4xi.py
ξ analyzed xml files with the more detailed trace
ξ learned to finf xxxxxxxx, yyyyyyyy and zzzzzzzz in a module after having decided the module is tagged !
ξ utilized both G11 and G19 keyboards together using command mode and two editors and switching profiles !
ξ discovered the benefits of G11 and G19 keyboards combined with macro4xi.py of our studio !

ξ decided NOT to use self-xxxxxxxx as noun with values self.xxxxxxxx because that would lead to several objects with the same start
ξ changed to use the verb pair calling and performed in class methods calling a function to ease debugging

ξ new: version
ξ message2print = "{performed" + "; save-performed-by-dump-of-ForkingPickler4Xi: " + str(self.save) + "; time: " + time4xi() + "}" <-- + best noun save
ξ print4xi(class2print, method2print, message2print)

ξ second version:
ξ message2print = "{performed" + "; self-save-performed-by-dump-of-ForkingPickler4Xi: " + str(self.save) + "; time: " + time4xi() + "}" <-- + better noun self-save
ξ print4xi(class2print, method2print, message2print)

ξ first version:
ξ message2print = "{performed" + "; self.save-performed-by-dump-of-ForkingPickler4Xi: " + str(self.save) + "; time: " + time4xi() + "}" <-- + refers to real one - not good as xml noun
ξ print4xi(class2print, method2print, message2print)

ξ tailored return with value when the value calculation was done in a complicated and in an essential module with a high risk:
ξ message2print = "{(Step 2/3) returning" + "; LONG-BINPUT-returning-by-put-of-ForkingPickler4Xi: " + time4xi() + "}"
ξ print4xi(class2print, method2print, message2print)
ξ return LONG_BINPUT + pack("
ξ detailed with step information some trace messages to differentiate them:
ξ message2print = "{(Step 2/9f) performed" + "; write-performed-by-save-of-ForkingPickler4Xi: " + str(self.write) + "; time: " + time4xi() + "}"
ξ print4xi(class2print, method2print, message2print)

January 5, 2010
ξ learned to be very careful not to touch original code
ξ hit errors when trying to print non callable class methods
ξ improved parameter passing trace and at the same time streamlined parameter names
ξ def MakeProxyType4Xi(name, exposed, cache={}): <-- name_param ....
ξ message2print = "{started" + "; MakeProxyType4Xi-started: " + str(MakeProxyType4Xi) + "; time: " + time4xi() + "}" <-- noun and its state: MakeProxyType4Xi-started
ξ message2print = "{passed" + "; name-passed-to-MakeProxyType4Xi: " + str(name) + "; time: " + time4xi() + "}" <-- parameter is unique in noun trace although !

ξ tagged c*4xi.py which includes constant modules
ξ embedded start messages which will show functions and methods as object in XML outputs

January 3, 2010
ξ tagged b*4xi.py
ξ created verb record for program history
ξ tagged current_process4xi.py - important module and big one to tag, G19 and G11 were great help

January 1, 2010
ξ locked with G19 to a certain program using keyboard menu - not Windows profile
ξ adjusted 8 ms timeout for texxxt block macros
ξ tagged b*4xi.py programs

December 31, 2009
ξ lost all profiles and all macros due to Logitech bug !
ξ reconfigured G19 and G11 - G11 can NOT assign text block without G19 software !
ξ recreated program macros by running macro4xi.py in studio
ξ solved problem with G11 and G19 which generated false and wrong charactes for macros making macros unusable by adding time delay to each macro
ξ realized that the less you dependend on others software and bugs, the better !
ξ discovered that Logitech software is unmature and full of bugs
ξ using USB contains risk with Vista and hardware - if possible connect directly to USB port

December 30, 2009
ξ started to macro a*4xi.p? modules

December 28, 2009
ξ compiled all, run find4xi.py in studio which revealed one verb error
ξ added profile tag to all programs with the appropriate profile code
ξ G11 intelligent keyboard installed to work with G19 keyboard
ξ verbs tag, scheme and parse added

December 23, 2009
ξ start to create a new drafonxi compiler
ξ skeleton_print4xi.py, autoproxy4xi.py and ace_objects4xi.py are the first to be compiled with the new dragonxi compiler

December 22, 2009
ξ reviewed verbs knowledgebase against skeleton_print4xi.py messages
ξ added verb profile to define profiles for tagging modules
ξ added verb operate for special Functions with capital letter

December 21, 2009
ξ explored whether ALL program macros should be of format such as #
ξ solved; macro4xi.py in studio creates macros from skeleton_print4xi.py
ξ whereas studio macros in folder program4xi can be named in any way i.e. specialize2import name is ok; specialize can be found also in macro4xi and skeleton_print4xi.py
ξ whereas tags differ and therefore one syntax is not possible

December 19, 2009
ξ challenge: some of the verbs designed to be used in the new xi compiler are NOT proper english
ξ class2variable and similar with 2 verbs !

December 18, 2009
ξ upgraded program tag verbs to verb modules and to skeleton_print4xi.py
ξ corrected message2print = "{initialize" + "; xxxxxxxx-initialize by-yyyyyyyy to: " + str(xxxxxxxx) + "; time: " + time4xi() + "}"
ξ use macro4xi.py to generate updated macros - this is a VERY useful tool in studio4xi !

December 17, 2009
ξ tag skeleton_print4xi.py !
ξ create profile for precense

December 16, 2009
ξ upgraded macro names to verbs and standardized macros for XML Schema
ξ upgraded skeleton_print4xi.py and macro4xi.py for XML Schema

December 15, 2009
»autoproxy4xi.py
ξ tagged the first program autoproxy4xi.py with ALL tags
ξ assigned different names for editor to get the right macro profile activated
ξ added presence to verbs into verb knowledgebases and skeleton_print4xi.py
ξ checked new verbs with test_skeleton_print4xi.py and find4xi.py
ξ fixed verb errors whether in verb knowledgebases or/and skeleton_print4xi.py
ξ set goals and designed the new dragonxi compiler; therefore the above upgrade to verb knowledgebase

December 14, 2009
ξ created different copies from crimson editor for different macro profiles to get profiles activated automatically when editor is being used
ξ developed program level tags to tag all modules for later analysis

December 10, 2009
»macro4xi.py
ξ to create keyboard macros from all source files with tag
ξ edited partly with G19 macros
ξ finished with Crimson macros
»constant_system4xi.py

December 09, 2009
»print4xi.py
ξ upgraded to import verbs, now each verb is defined in its own module and all verbs in verb4xi
ξ created first G19 macrofiles to speed command mode operations

December 08, 2009
ξ upgraded sense, reason and ace of current_process4xi which is a VERY important module
ξ reason-verb4xi.xml <-- VERBS in XML * NEW *!
»test_verbkb4xi.py
»verb4xi.py
»verb2a4xi.py <- to a, b, c..... all alphabetically !

December 07, 2009
ξ find4py.py can be used to search source codes based on verbs and nouns
ξ for example: noun-to-be-searched: object-of- verb-to-be-search: activated
ξ depicting variables in trace instead of changing original program variables minimizes risks to alter program logic
ξ started editing current_process4xi which is a VERY important module

December 06, 2009
ξ skeletons seem to work bot for classes and function; A and P done !
ξ passed information must be updated and data flow in general !

December 05, 2009
ξ challenges with time object; skipped now if not identified in detail of which object it is
ξ challenges with ace method in print4xi; has to handle knowledgebases i.e. dictionaries

December 04, 2009
ξ it looks like we have the concept ok and ready for full scale implementation !
ξ macro keys and profiles - maybe one for function and one for classsed - need to be designed

December 02, 2009
ξ having added the function, class actor makes it unnecessary to name parameters to xxxxxxx_param !

December 02, 2009
ξ skeleton_print4xi.py
ξ added -verb to each noun to differentiate nouns in aced XML
ξ message2print = "{aced" + "; xxxxxxxx-aced: " + "xxxxxxxx" + "; time: " + time4xi() + "}"
ξ test_skeleton_print4xi.py
ξ ace-test-skeleton-print4xi.xml

December 01, 2009
ξ test_constant_heap4xi.py
ξ created also Heap4Xi object and testes sense, reason and ace methods of Heap4Xi - not just ConstantHeap4Xi
ξ heap4xi.py
ξ sense method added to common object knowledge self._xxxxxxx values it can access directly
ξ if StepOriginal is used, use the noun original-function, not function to differentiate
ξ use verbs unresolved, skipped to depict problems to be solved

November 30, 2009
ξ started to embed new sense, reason and ace methods to modules
ξ checked ''' ''' which should NOT containg hyphen; compiler does NOT handle it ok but instead you have code commented !!!
ξ this is why ..... kind of tagging would be better !

November 28, 2009
ξ developed sense, reason andd ace for functions
»skeleton_print4xi.py

November 27, 2009
ξ tested that sense, reason and ace methods are capable to add object specific data
ξ updated new sense, reason and ace methods to A, B and C modules and to test_constant_*4xi.py modules

November 26, 2009
»Test of skeleton_print4xi.py
ξ Module
ξ Trace
ξ SENSE
ξ REASON
ξ ACE
ξ sense_object4x <-- new!
ξ reason_object4x <-- new!
ξ ace_object4x <-- new!

ξ private_methods
ξ public_methods

November 25, 2009

Started to update tracing in ALL modules
ξ modules to define public API of class and functions!
ξ classes to define public API of methods
ξ __init_ of all classed to have started, borning, activated and returning verbs

»print4xi.py
ξ new verbs; verbs dictionary split into modules;
»skeleton_print4xi
ξ more message skeletons for modules; sense,reason and ace method skeletons for classes

Best Practices
ξ use descriptive verbs such as borning in __init__ instead of starting
ξ use descriptive nouns - not necessary those of used by a programmer <-- this might be a BAD idea !!!
ξ differentiate __init__ method messages
ξ utilize sense, reason and ace method skeletons
ξ continuously invent ways to achieve goals such that info exists only once !
ξ if possible (do NOT touch existing ones), name function parameters wisely i.e. do NOT use just param!

XML TRACE

Step 1: go2multicore; run t_all4xi
ξ XML SENSE

Step 2: go2studio; run find4xi > ..\txt\xml4xi.txt - see with editor it if there has been any errors dealing with XML !
ξ XML SENSE

»xml_trace_sense4xi.py - SENSE
»xml_trace_reason4xi.py - REASON
»xml_trace_ace4xi.py - ACE

Step 3: Check text file where you directed output (search SENSED ACTIVE)
ξ a. compare above to the following in text output of the test!
ξ b. correct print4xi.py if the below active list does not contain a function or class!
ξ c. correct above trace setting, if necessary - compare to imports!
ξ d. search error in text output of the test!

Notes
1) you do NOT have to give print permissions to class methods !
2) .txt contains both normal text messages and statitics created by sense method of Print4Xi XML-tagged for later analysis

ξ -----------------------------------------------------------------------------------------
ξ SENSED ACTIVE - test-dragonized-multiprocessing4xi <-- do NOT try to generate these in sense_print4xi function of print4xi.py !!!
ξ run: ConstantFamily4Xi ....
ξ ===================
ξ TOTAL - test-dragonized-multiprocessing4xi
ξ Passive objects: 478
ξ Run objects: 16 <-- check this!

November 20, 2009

14. »Test of format4xi.py
ξ Module
ξ Trace
ξ SENSE
ξ REASON
ξ ACE
ξ print4xi.py <-- embeds with format function
ξ note: print4xi can NOT use format4xi function because format4xi uses print4xi function!

November 19, 2009

13. »Test of constant_synchronize4xi.py
ξ Module
ξ Trace
ξ SENSE
ξ REASON
ξ ACE

November 18, 2009

12. »Test of cpu_corecount4xi.py
ξ Module
ξ Trace
ξ SENSE
ξ REASON
ξ ACE

November 17, 2009

11. »Test of constant_process4xi.py
ξ Module
ξ Trace
ξ SENSE
ξ REASON
ξ ACE

10. »Test of constant_pool4xi.py
ξ Module
ξ Trace
ξ SENSE
ξ REASON
ξ ACE

9. »Test of constant_managers4xi.py
ξ Module
ξ Trace
ξ SENSE
ξ REASON
ξ ACE

November 16, 2009

8. »Test of constant_logger4xi.py
ξ Module
ξ Trace
ξ SENSE
ξ REASON
ξ ACE

7. »Test of constant_heap4xi.py
ξ Module
ξ Trace
ξ SENSE
ξ REASON
ξ ACE

6. »Test of constant_forking4xi.py
ξ Module
ξ Trace
ξ SENSE
ξ REASON
ξ ACE

5. »Test of constant_family4xi.py
ξ Module
ξ Trace
ξ SENSE
ξ REASON
ξ ACE

November 14, 2009

4. »Test of constant_util4xi.py
ξ Module
ξ Trace
ξ SENSE
ξ REASON
ξ ACE

3. »Test of constant_connection4xi.py
ξ Module
ξ Trace
ξ SENSE
ξ REASON
ξ ACE

2. ξ hello_world4xi (is a test program)
ξ Trace
ξ SENSE
ξ REASON
ξ ACE

1. »Test of constant_system4xi.py
ξ Module
ξ Trace
ξ SENSE
ξ REASON
ξ ACE

ξ skeleton_print4xi
ξ new message syntax for XML sensing, reasoning and acing
ξ this module is used to modify ALL programs to conform to the new message format !
ξ you also have to keep VerbKB4Xi updated in print4xi.py module !

Modified the modules participating to the test to conform to new message format required by Print4Xi and sense/reason/ace methods used by hello_world4xi.py
example:
ξ »current_process4xi.py
ξ modify print4xi messages
ξ same for all modules in this test!

November 6, 2009

01) print4Xi »print4xi.py
ξ produces XML files for browsers for sense and reason
ξ has to handle () to find verbs in messages
ξ modules must modify messages for print4xi
ξ print4xi has to delete < and > inside messages because browsers do NOT accept them !

01) print4Xi »test_constant_system4xi.py
ξ OK with new print4xi
ξ acing of trace is missing because print4xi ace method returns {} dictionary!
ξ Trace
ξ sense.xml
ξ reason.xml

02)
ξ »hello_world4xi.py
ξ Trace

03)
ξ »skeleton_print4xi
ξ new syntax for modules to use print4xi

November 3, 2009

01) print4Xi »print4xi.py with test_constant_system4xi.py ΔΔΔ
ξ improved tracing
ξ returns statistics showing which modules have been running during the test
02) test_constant_system4xi »test_constant_system4xi.py ΔΔΔ
ξ uses new print4xi
ξ Trace ΔΔΔ
03) constant_system4xi »constant_system4xi.py

To be done
1. _tls.process_handle- where given to Popen4Xi, where is Popen4Xi called ?

2. Why is forking.py Class Popen #line 343 called !???

3. Process4Xi <-- calls Popen4Xi!
ξ forking.py is mysterious:
ξ ForkingPickler.register is called in many place
ξ how do these code pieces get called
ξ only when you import forking.py !?

4. OWL/XML files for constants (*) list4xi.py (*)__init__.py for xi4

5. (*) global obj (*) to be done search (*) 4xi.py: mp (*) _xxxxxx4xi (*) _reset4xi (*) ? lines

Python 3.3 Environment

Command mode environment
ξ you can open several command mode windows to test performance (open task manager windows)
ξ go2multicore.bat <--- the command in the user folder to get to the right folder and to set environment variables

Batch Files
t custom_mp_xi2 <--- program to be compiled
t-all4xi <-- compiles and runs all programs

Studio:
go2studio
fin4xi.py <-- update search keys here
find4xi >..\txt\current_process.txt <-- example search

Multiprocessing4xi:
go2multicore
t_all4xi.bat: compiles all multiprocessing4xi files; calls only working test programs; echoes the ones being tested
t4xi.bat: the current work compilation and test
t.bat: one module compilation/test; t hello_world4xi >..\txt\hello_world4xi.txt

~[Σ] ~[Ω]!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Small & Smart Inc reserves rights to change this document without any notice
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

ΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞ
~ Macros Δ ~ Parsing Δ ~ Time Δ	~ Verbalize Δ ~ Symbolize2verb4xi Δ ~ Walk Δ	~ Zap Δ ~ Fetching Scope4Xi Programs Δ ~ Building Scope Programs Δ
~ Fetch2url4scope Δ ~ To-be-solved Δ ~ Nouns Δ	~ Version Δ ~ Finding Δ ~ To-be-done Δ	~ Symbolize2actor Δ ~ Print4Xi Δ ~ Dragonizing Δ
~ Generating Image Programs for Devices Δ ~ Program Macros Δ ~ Developer Macros Δ	~ Tag Profile Codes Δ ~ Verbs and Scoping Δ ~ Profiles for Kyeboard Δ	~ Utility Tester Profile Δ ~ Multicore CPU sensing Δ ~ Commander Profile Δ
~ Module Tester Profile Δ ~ Scoped Sense-, Ace- and Reason-XML-files Δ ~ Zapped Programs Δ	~ Deployment to Scope4xi Δ ξ All modules dragonized Δ ξ WEB4Xi Δ	~ Ctypes and Multiprocessing ~ Proxy Objects in Multiprocessing ~ Benchmarks in Multiprocessing
~ Server with Pool Workers ~ Calculating with Pool of Workers ~ Locks and Semaphores	ξ Server with Pool Workers ξ Constants4Xi Δ Δ Δ ξ Managers	~ _init__ (Manager4Xi) Δ Δ (package missing) ξ Multicore CPU Test Δ Δ Δ ξ Locks and Semaphores Test Δ
ξ Process Reference Δ ξ Pool of workers with Pool4Xi Δ ξ Manager with Manager4Xi Δ	ξ Benchmarks Δ ξ Proxy Objects ξ Customized Manager and Proxies Δ	ξ Calculating with Pool of Workers Δ ξ Test All Methods4Xi ξ Connection dummy DRAGONIZED
ξ Synchronization with Lock4Xi Δ ξ Pipes with Process4Xi, Queue4Xi and Pipe4Xi Δ ξ Queues with Process4Xi and Queue4Xi Δ	ξ Ctypes with ArrayFunction4Xi Δ ξ Connection module Δ Δ Δ ξ Synchronization module Δ Δ Δ	ξ Process Δ Δ Δ ξ Managers Δ Δ Δ ξ Forking Δ Δ Δ
ξ Heap Δ Δ Δ ξ Pool Δ Δ Δ ξ Queue Δ Δ Δ	ξ Reduction Δ Δ Δ ξ Sharedctypes Δ Δ Δ ξ Util Δ Δ Δ	ξ BLOG Δ
ΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞΞ