# d2b.py
#
# Decimal to byte(s) and character/string to byte(s) converter.
# Any decimal number from 0 to 255 converted to b"\x??" format.
# Any standard ASCII string, something like "\x00Some String.\xFF" converted
# to b"\x00Some String.\xff". NOTE:- "FF" is displayed as "ff" on conversion
# but the end result is the same.
#
# NOTE:- The reverse, b"\x00Some String.\xff" converted to
# "\x00Some String.\xff", is easy and therefore not included in this function.
#
# What I needed......
# The function, sometext=chr(a+b), (where "a" could be for example 127 and
# "b" in this case is -127<=b<=128), capability is not easily possible with the
# b"string" byte(s) format so this function was devised.
#
# See here for an example of chr(a+b):-
# http://code.activestate.com/recipes/578013-amplitude-modulation-tremolo-was-an-audiosound-sni/?in=lang-python
#
# This new function uses NO import(s), nor any special programming style,
# but is written so that anyone can understand, (including kids), how it works.
# It does NOT need any special encoding or any other "Pythonic" requirements at all.
# It is not "elegant", as professionals may call it, but, it is functional.
#
# I have no idea at all as to the upper limit of ASCII string length it can
# handle, however it CAN handle a(n) "", (empty), string.
#
# ==========================================================================
#
# Python 3.1.3 (r313:86834, Nov 28 2010, 10:01:07) 
# [GCC 4.4.5] on linux2
# Type "help", "copyright", "credits" or "license" for more information.
# >>> exec(open('/home/G0LCU/Desktop/Code/d2b.py').read())
# >>> a=78
# >>> type(a)
# <class 'int'>
# >>> b=d2b(a)
# >>> print(b)
# b'N'
# >>> type(b)
# <class 'bytes'>
# >>> text="\x00(C)2012, B.Walker, G0LCU.\xFF"
# >>> len(text)
# 27
# >>> type(text)
# <class 'str'>
# >>> newtext=t2b(text)
# >>> len(newtext)
# 27
# >>> print(newtext)
# b'\x00(C)2012, B.Walker, G0LCU.\xff'
# >>> type(newtext)
# <class 'bytes'>
#
# ============================================================================
#
# Copyright, (C)2012, B.Walker, G0LCU.
# Issued under GPL2 licence...
# Enjoy finding simple solutions to often very difficult problems.
#
# Requires Python Version 3.x.x only.
# Tested on Debian 6.0.0 using Python 3.1.3, and PCLinuxOS 2009 using Python 3.2.1.
# Also Tested on MS Windows Vista, 32 bit, using Python 3.0.1 and Python 3.2.2.

# Decimal number to byte(s) string converter.
def d2b(a,b=0):
	# "a" any decimal number between 0 to 255.
	# "b" is reserved, but for my usage is very useful, see above... ;o)
	# Don't allow any floating point numbers.
	a=int(a)
	b=int(b)
	decimal=a+b
	# Out of range checks forcing function to exit!
	if decimal<=-1 or decimal>=256:
		print("\nError in d2b(a,b=0) function, decimal integer out of range, (0 to 255)!\n")
		# FORCE a Python error to stop the function from proceeding; "FORCED_HALT" IS NOT DEFINED!
		print(FORCED_HALT)
	# Convert new decimal value 0 to 255 to b"\x??" value.
	if decimal==0: newbyte=b"\x00"
	if decimal==1: newbyte=b"\x01"
	if decimal==2: newbyte=b"\x02"
	if decimal==3: newbyte=b"\x03"
	if decimal==4: newbyte=b"\x04"
	if decimal==5: newbyte=b"\x05"
	if decimal==6: newbyte=b"\x06"
	if decimal==7: newbyte=b"\x07"
	if decimal==8: newbyte=b"\x08"
	if decimal==9: newbyte=b"\x09"
	if decimal==10: newbyte=b"\x0A"
	if decimal==11: newbyte=b"\x0B"
	if decimal==12: newbyte=b"\x0C"
	if decimal==13: newbyte=b"\x0D"
	if decimal==14: newbyte=b"\x0E"
	if decimal==15: newbyte=b"\x0F"
	if decimal==16: newbyte=b"\x10"
	if decimal==17: newbyte=b"\x11"
	if decimal==18: newbyte=b"\x12"
	if decimal==19: newbyte=b"\x13"
	if decimal==20: newbyte=b"\x14"
	if decimal==21: newbyte=b"\x15"
	if decimal==22: newbyte=b"\x16"
	if decimal==23: newbyte=b"\x17"
	if decimal==24: newbyte=b"\x18"
	if decimal==25: newbyte=b"\x19"
	if decimal==26: newbyte=b"\x1A"
	if decimal==27: newbyte=b"\x1B"
	if decimal==28: newbyte=b"\x1C"
	if decimal==29: newbyte=b"\x1D"
	if decimal==30: newbyte=b"\x1E"
	if decimal==31: newbyte=b"\x1F"
	if decimal==32: newbyte=b"\x20"
	if decimal==33: newbyte=b"\x21"
	if decimal==34: newbyte=b"\x22"
	if decimal==35: newbyte=b"\x23"
	if decimal==36: newbyte=b"\x24"
	if decimal==37: newbyte=b"\x25"
	if decimal==38: newbyte=b"\x26"
	if decimal==39: newbyte=b"\x27"
	if decimal==40: newbyte=b"\x28"
	if decimal==41: newbyte=b"\x29"
	if decimal==42: newbyte=b"\x2A"
	if decimal==43: newbyte=b"\x2B"
	if decimal==44: newbyte=b"\x2C"
	if decimal==45: newbyte=b"\x2D"
	if decimal==46: newbyte=b"\x2E"
	if decimal==47: newbyte=b"\x2F"
	if decimal==48: newbyte=b"\x30"
	if decimal==49: newbyte=b"\x31"
	if decimal==50: newbyte=b"\x32"
	if decimal==51: newbyte=b"\x33"
	if decimal==52: newbyte=b"\x34"
	if decimal==53: newbyte=b"\x35"
	if decimal==54: newbyte=b"\x36"
	if decimal==55: newbyte=b"\x37"
	if decimal==56: newbyte=b"\x38"
	if decimal==57: newbyte=b"\x39"
	if decimal==58: newbyte=b"\x3A"
	if decimal==59: newbyte=b"\x3B"
	if decimal==60: newbyte=b"\x3C"
	if decimal==61: newbyte=b"\x3D"
	if decimal==62: newbyte=b"\x3E"
	if decimal==63: newbyte=b"\x3F"
	if decimal==64: newbyte=b"\x40"
	if decimal==65: newbyte=b"\x41"
	if decimal==66: newbyte=b"\x42"
	if decimal==67: newbyte=b"\x43"
	if decimal==68: newbyte=b"\x44"
	if decimal==69: newbyte=b"\x45"
	if decimal==70: newbyte=b"\x46"
	if decimal==71: newbyte=b"\x47"
	if decimal==72: newbyte=b"\x48"
	if decimal==73: newbyte=b"\x49"
	if decimal==74: newbyte=b"\x4A"
	if decimal==75: newbyte=b"\x4B"
	if decimal==76: newbyte=b"\x4C"
	if decimal==77: newbyte=b"\x4D"
	if decimal==78: newbyte=b"\x4E"
	if decimal==79: newbyte=b"\x4F"
	if decimal==80: newbyte=b"\x50"
	if decimal==81: newbyte=b"\x51"
	if decimal==82: newbyte=b"\x52"
	if decimal==83: newbyte=b"\x53"
	if decimal==84: newbyte=b"\x54"
	if decimal==85: newbyte=b"\x55"
	if decimal==86: newbyte=b"\x56"
	if decimal==87: newbyte=b"\x57"
	if decimal==88: newbyte=b"\x58"
	if decimal==89: newbyte=b"\x59"
	if decimal==90: newbyte=b"\x5A"
	if decimal==91: newbyte=b"\x5B"
	if decimal==92: newbyte=b"\x5C"
	if decimal==93: newbyte=b"\x5D"
	if decimal==94: newbyte=b"\x5E"
	if decimal==95: newbyte=b"\x5F"
	if decimal==96: newbyte=b"\x60"
	if decimal==97: newbyte=b"\x61"
	if decimal==98: newbyte=b"\x62"
	if decimal==99: newbyte=b"\x63"
	if decimal==100: newbyte=b"\x64"
	if decimal==101: newbyte=b"\x65"
	if decimal==102: newbyte=b"\x66"
	if decimal==103: newbyte=b"\x67"
	if decimal==104: newbyte=b"\x68"
	if decimal==105: newbyte=b"\x69"
	if decimal==106: newbyte=b"\x6A"
	if decimal==107: newbyte=b"\x6B"
	if decimal==108: newbyte=b"\x6C"
	if decimal==109: newbyte=b"\x6D"
	if decimal==110: newbyte=b"\x6E"
	if decimal==111: newbyte=b"\x6F"
	if decimal==112: newbyte=b"\x70"
	if decimal==113: newbyte=b"\x71"
	if decimal==114: newbyte=b"\x72"
	if decimal==115: newbyte=b"\x73"
	if decimal==116: newbyte=b"\x74"
	if decimal==117: newbyte=b"\x75"
	if decimal==118: newbyte=b"\x76"
	if decimal==119: newbyte=b"\x77"
	if decimal==120: newbyte=b"\x78"
	if decimal==121: newbyte=b"\x79"
	if decimal==122: newbyte=b"\x7A"
	if decimal==123: newbyte=b"\x7B"
	if decimal==124: newbyte=b"\x7C"
	if decimal==125: newbyte=b"\x7D"
	if decimal==126: newbyte=b"\x7E"
	if decimal==127: newbyte=b"\x7F"
	if decimal==128: newbyte=b"\x80"
	if decimal==129: newbyte=b"\x81"
	if decimal==130: newbyte=b"\x82"
	if decimal==131: newbyte=b"\x83"
	if decimal==132: newbyte=b"\x84"
	if decimal==133: newbyte=b"\x85"
	if decimal==134: newbyte=b"\x86"
	if decimal==135: newbyte=b"\x87"
	if decimal==136: newbyte=b"\x88"
	if decimal==137: newbyte=b"\x89"
	if decimal==138: newbyte=b"\x8A"
	if decimal==139: newbyte=b"\x8B"
	if decimal==140: newbyte=b"\x8C"
	if decimal==141: newbyte=b"\x8D"
	if decimal==142: newbyte=b"\x8E"
	if decimal==143: newbyte=b"\x8F"
	if decimal==144: newbyte=b"\x90"
	if decimal==145: newbyte=b"\x91"
	if decimal==146: newbyte=b"\x92"
	if decimal==147: newbyte=b"\x93"
	if decimal==148: newbyte=b"\x94"
	if decimal==149: newbyte=b"\x95"
	if decimal==150: newbyte=b"\x96"
	if decimal==151: newbyte=b"\x97"
	if decimal==152: newbyte=b"\x98"
	if decimal==153: newbyte=b"\x99"
	if decimal==154: newbyte=b"\x9A"
	if decimal==155: newbyte=b"\x9B"
	if decimal==156: newbyte=b"\x9C"
	if decimal==157: newbyte=b"\x9D"
	if decimal==158: newbyte=b"\x9E"
	if decimal==159: newbyte=b"\x9F"
	if decimal==160: newbyte=b"\xA0"
	if decimal==161: newbyte=b"\xA1"
	if decimal==162: newbyte=b"\xA2"
	if decimal==163: newbyte=b"\xA3"
	if decimal==164: newbyte=b"\xA4"
	if decimal==165: newbyte=b"\xA5"
	if decimal==166: newbyte=b"\xA6"
	if decimal==167: newbyte=b"\xA7"
	if decimal==168: newbyte=b"\xA8"
	if decimal==169: newbyte=b"\xA9"
	if decimal==170: newbyte=b"\xAA"
	if decimal==171: newbyte=b"\xAB"
	if decimal==172: newbyte=b"\xAC"
	if decimal==173: newbyte=b"\xAD"
	if decimal==174: newbyte=b"\xAE"
	if decimal==175: newbyte=b"\xAF"
	if decimal==176: newbyte=b"\xB0"
	if decimal==177: newbyte=b"\xB1"
	if decimal==178: newbyte=b"\xB2"
	if decimal==179: newbyte=b"\xB3"
	if decimal==180: newbyte=b"\xB4"
	if decimal==181: newbyte=b"\xB5"
	if decimal==182: newbyte=b"\xB6"
	if decimal==183: newbyte=b"\xB7"
	if decimal==184: newbyte=b"\xB8"
	if decimal==185: newbyte=b"\xB9"
	if decimal==186: newbyte=b"\xBA"
	if decimal==187: newbyte=b"\xBB"
	if decimal==188: newbyte=b"\xBC"
	if decimal==189: newbyte=b"\xBD"
	if decimal==190: newbyte=b"\xBE"
	if decimal==191: newbyte=b"\xBF"
	if decimal==192: newbyte=b"\xC0"
	if decimal==193: newbyte=b"\xC1"
	if decimal==194: newbyte=b"\xC2"
	if decimal==195: newbyte=b"\xC3"
	if decimal==196: newbyte=b"\xC4"
	if decimal==197: newbyte=b"\xC5"
	if decimal==198: newbyte=b"\xC6"
	if decimal==199: newbyte=b"\xC7"
	if decimal==200: newbyte=b"\xC8"
	if decimal==201: newbyte=b"\xC9"
	if decimal==202: newbyte=b"\xCA"
	if decimal==203: newbyte=b"\xCB"
	if decimal==204: newbyte=b"\xCC"
	if decimal==205: newbyte=b"\xCD"
	if decimal==206: newbyte=b"\xCE"
	if decimal==207: newbyte=b"\xCF"
	if decimal==208: newbyte=b"\xD0"
	if decimal==209: newbyte=b"\xD1"
	if decimal==210: newbyte=b"\xD2"
	if decimal==211: newbyte=b"\xD3"
	if decimal==212: newbyte=b"\xD4"
	if decimal==213: newbyte=b"\xD5"
	if decimal==214: newbyte=b"\xD6"
	if decimal==215: newbyte=b"\xD7"
	if decimal==216: newbyte=b"\xD8"
	if decimal==217: newbyte=b"\xD9"
	if decimal==218: newbyte=b"\xDA"
	if decimal==219: newbyte=b"\xDB"
	if decimal==220: newbyte=b"\xDC"
	if decimal==221: newbyte=b"\xDD"
	if decimal==222: newbyte=b"\xDE"
	if decimal==223: newbyte=b"\xDF"
	if decimal==224: newbyte=b"\xE0"
	if decimal==225: newbyte=b"\xE1"
	if decimal==226: newbyte=b"\xE2"
	if decimal==227: newbyte=b"\xE3"
	if decimal==228: newbyte=b"\xE4"
	if decimal==229: newbyte=b"\xE5"
	if decimal==230: newbyte=b"\xE6"
	if decimal==231: newbyte=b"\xE7"
	if decimal==232: newbyte=b"\xE8"
	if decimal==233: newbyte=b"\xE9"
	if decimal==234: newbyte=b"\xEA"
	if decimal==235: newbyte=b"\xEB"
	if decimal==236: newbyte=b"\xEC"
	if decimal==237: newbyte=b"\xED"
	if decimal==238: newbyte=b"\xEE"
	if decimal==239: newbyte=b"\xEF"
	if decimal==240: newbyte=b"\xF0"
	if decimal==241: newbyte=b"\xF1"
	if decimal==242: newbyte=b"\xF2"
	if decimal==243: newbyte=b"\xF3"
	if decimal==244: newbyte=b"\xF4"
	if decimal==245: newbyte=b"\xF5"
	if decimal==246: newbyte=b"\xF6"
	if decimal==247: newbyte=b"\xF7"
	if decimal==248: newbyte=b"\xF8"
	if decimal==249: newbyte=b"\xF9"
	if decimal==250: newbyte=b"\xFA"
	if decimal==251: newbyte=b"\xFB"
	if decimal==252: newbyte=b"\xFC"
	if decimal==253: newbyte=b"\xFD"
	if decimal==254: newbyte=b"\xFE"
	if decimal==255: newbyte=b"\xFF"
	return(newbyte)

# Text/Character string to byte(s) string converter.
# "some_string" is any ASCII string including "\x??" characters as required.
def t2b(some_string):
	# Allocate an empty byte(s) string.
	new_byte_string=b""
	# Use the loop to build the byte(s) string from a standard string.
	for n in range(0,len(some_string),1):
		# Convert each _character_ in the string to a decimal number.
		decimal_number=ord(some_string[n])
		# Call the "d2b()" above function.
		d2b_character=d2b(decimal_number)
		# Build the byte(s) string one character at a time.
		new_byte_string=new_byte_string+d2b_character
	# The complete byte(s) string has now been converted.
	return(new_byte_string)

# End of d2b() function...
# Enjoy finding simple solutions to often very difficult problems... ;o)