196 IX: prepIX (196.html)

Keywords

IX or DC (IX by DC) or "|><"

Introduction

Upcoming Changes

• The final name change to "prepIX.py" is the final step (Phase II) towards the addition of some limited macro functionality to the current "prepping" process.
• The intermediate name will be "prepIX_I.py" as Phase I
• The folder to be searched (for macro definitions) will be "/home/pi/Desktop/IX_assets/ix/"
• The incoming file name extension will be .pyix not .pb
• "requests" will be deprecated by "requires". (This is a work-in-progress.)

The prepIX Lexicon

• callable routines: these are defined python functions (beginning with "def") that have an entry point and at least one return (or yield) statement. Each return statement can return zero or more values.
• code: A series of statements that all conform to certain syntax rules.
• continuation statement: A statement that continues on the next line. For python, a "\" at the end of a line marks a continuation statement
• current folder: the folder that contains the proto-build-module (with an extension of ".pb")
      This folder also houses the prepIX.py module.
• final statements: comment statement inserted at the end of a built program to list its required functions, name it and
      date/timestamp it
• full comment statement: a full row of text that begins/ends with a special phrase (eg "#" for python.
• imported modules: An "import" statement in a module causes code to be inserted into a program. Sometimes, the code is visible in the listing, sometimes not
• import statements: The statements that are inserted into a program due to an "import" statement.
• in-line modules: these modules are not "required" nor "imported" because they are defined as part of the program's main code.
• ix library folder: this folder contains the "ix" library. It is "/home/pi/Desktop/IX_assets/ix/"
• ix macro invocation: A single (or multi) line macro can be invoked eg. "python test1_py.pyix?count=10"
  (".pyix" has deprecated ".ix" as of 2024CMar30)
• library: a group of routines (functions or modules) that can be optionally used by a python program. Such modules can be "imported" or "required".
• macro entity: A macro entity is a tiny piece of place-holder code that will be replaced by one or more actual lines of code. Some     macro processors permit the insertion of a partial line of code. But the IXc macro processor does not.
      The programmer can define the value of zero or more entities when the macro phrase is invoked.
• macro invocation: A macro phrase is a place-holder specifying the name of a macro. The macro processor replaces
      it by one or more lines of code. The IXc macro processor invokes one or more macros, concatenates them together
      and produces a resulting code segment. An example is "-python anyPreTest1_py.PYix?steps=10 test1_py.PYix?count=5 DCole".
      See Source 03 for more info.
• macro phrase: A macro phrase "tells" the macro processor the name of one or more lines of code. See "macro invocation".
• macro processor: A macro processor inserts macro code into a module by replacing entities with code.
      The replacement code is defined when the macro processor is invoked. Source 03 has more
      information about the IX macro processor. See "ix macro invocation" in this lexicon.
• main module: In normal python, the main program code generally can be interspersed with all of the modules that it needs to function.
      However, each module (or function) must be defined (or imported or required) before it is referenced (used).
• module: multiple lines of code that make up an in-line (function) module, an import module, a required module or a main module
• prep comments: These are full comment statements that are added to the built program to document the prepping process.
• prepIX: A python program that converts a valid proto-build-module (extension: ".pb") into a fully runnable python program.
• proto-build-module: this set of python code is a valid python code module (except that its extension is ".pb"), but is lacking the definitions of some routines (callable routines) that it calls. These routines must be required to be included using a "requires" statement.
• python: The coding language that is used throughout the prepIX system. MicroPython, CircuitPython, CPython and Thonny all can use "prepIX.py" .
• requires folders: these two folders are searched when prepIX.py is looking for a required module. No other libraries are used by the prepIX.py program. None are external to the computer.
      These two folders are the /home/pi/Desktop/IX_assets/ix/ folder and the current folder. The /home/pi/Desktop/IX_assets/ix/ folder serves as a library for "prepIX.py".
• required list: This commented list of the "required" modules is appended to the program that is built by "prepIX.py".
• required module: A "requires" statement causes this required code to be inserted into a progrm. A "required module" always begins with a "def" statement. All of the "required" code is always visible in the program that is built by "prepIX.py".
• RUPasc This is the recommended vector format for a list of readings.
• separation statement: A statement containing many "#" characters to separate required modules
• trailing comment : A comment (that begins with a "#") that follows on the same line as a python statement. These comments persist in the built module.
• :
• :

Interactions between the IXc macro Processor and prepIX.py

prepIX program status

A Simple prepIX_I Example

A Proto-Build-Module Example

	print("main.py program")
	#main.pb     #proto file for main.py
	#By: D@CC
	#Date: 2023EMay17

	requires("requires(s,'v==00')")
	requires("show(s,s,s,'v==00')")
	requires("showY(s,s,'v==00')")

	print("main.py proto-build-module")
	isShow=True
	strName="D@CC"
	show("strName",strName,isShow)
	print("end of main.py")
	

Resulting Module Built From the Above Proto-Build-Module Example

	print("main.pb program")
	
	def requires(fcall,strMsg=""):
	    if not strMsg=="": print("ErrRequest:",fcall,": ",strMsg)
	    return strMsg
	
	#def end requires
	requires("requires(s,v)")
	############################################
	def show(objName,obj,isShow):
	
	    if not isShow: return
	    if not isinstance(objName,str):
	        print("Error S01 in show Name is not a str:",objname)
	    if isinstance(obj, str) or isinstance(obj,list) or isinstance(obj,int)or isinstance(obj,bool):
	        print(objName,":",obj,":")
	    else:
	        typeObj=type(obj)
	        print("Error S02 in show obj is not a str, list, int nor bool:",objName,"type:",typeObj,"value:",obj)
	        return
	
	#def end show
	requires("show(s,s,B,v)")
	############################################
	requires("showY(s,s,B,v)","does NOT exist.")
	############################################
	print("main.py proto file")
	isShow=True
	strName="D@CC"
	show("strName",strName,isShow)
	print("end of main.py  proto-build-module")
	#main.py (created by prepIX.py)
	#        on 2023-05-16 T 01:22:57
	

Results When this Program is Run

	>>>$ cd Desktop
	>>>$ python main.py
	

	main.pb program
	ErrRequest: showY(s,s,B,v) : does NOT exist
	main.py proto file
	strName : D@CC :
	end of main.py  proto-build-module
	

Folder Contents For prepIX.py

	/home/pi/Desktop/
		prepIX_WioT_v01o03_2023EMay17.py
		main.pb
	/home/pi/Desktop/ix/
		requires.py
		show.py
	

The IXc Command and the Bourne Shell

   > $ IXc
   > ! -sh Environ_ix.sh?date=2022FJun21 DCole

The IX Family of Software

Other Related Thoughts

Pi Shop in Ottawa

	HiPi Industries Inc.
	DBA PiShop.ca
	9-190 Colonnade Rd. S.
	Ottawa ON, K2E 7J5
	GST & HST# 796009322
	Monday-Friday 9am-5pm EST
	844-850-1100
	Email: support@pishop.ca
	

Sources

Video Sources

First Look at the Tiny2040 (3:14 min)

Web Sources