diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..eb12ee7
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,57 @@
+# Created by https://www.gitignore.io
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.cache
+nosetests.xml
+coverage.xml
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
\ No newline at end of file
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..c04a403
--- /dev/null
+++ b/README.md
@@ -0,0 +1,60 @@
+# IBOOTPY
+A simple tool that to replace the perl script provided with first generation iboot devices.  Has been tested with an iBoot G2 and demonstrated to work.
+
+## Installation
+In a virtual env, anaconda env, or other Python 3.x install you can simply run `python setup.py install`.
+
+This will add a iboot module to the site-packages as well as an ibootpy binary to the path
+
+### Files Created
+ * ibootpy - located in python environments 'bin' directory.
+ * iboot-0.1.0-py<ver>.egg - located (for anaconda) inside the environments lib/pythonX/site-packages/ folder.
+
+
+## Inspiration
+During an expansion of our lab management infrastructure we discovered the older perl script no longer functioned due to the move to the DxP protocol on newer devices. Fortunately the basic infrastructure for making DxP work via python existed, since the provided C libraries rely on winsock and are windows only.  This expands the original library to provide a full tool for ease of use.
+
+## Usage
+This update provides a basic command-line tool for using the DxP protocol allowing status checks, toggling relays, and setting all relays to on or off. It can be run using the command `ibootpy`.
+
+```
+ibootpy [-h] [--port PORT] [-v] [-q] [--debug] IP USER PASSWORD ACTION
+
+ibootpy - iBoot DxP Tool
+
+positional arguments:
+  IP             IP you wish to interact with
+  USER           User Name
+  PASSWORD       Device Password
+  ACTION         Action to perform on list of iBoot Devices (default status)
+
+optional arguments:
+  -h, --help     show this help message and exit
+  --port PORT    Port to communicate with device
+  -v, --verbose  verbose output
+  -q, --quiet    silence output, simply return success or failure.
+  --debug        Enable Debug Output
+
+```
+
+## Alterations From Base Package
+
+### Python Version
+This module is now adjusted to be compliant with Python 3.
+
+### Get Relays
+This now returns a dictionary of the relays correctly formatted for toggling and setting updates by updating the individual relay entries and feeding the dictionary back to the interface.
+
+### Logging
+No longer institutes default DEBUG output, simply provides a logger called 'iBootInterface', when running ibootpy this defaults to INFO level output with flags to enable DEBUG or silence all output.
+
+### iBootDevice Interface Setup
+The interface will now directly accept strings for username and password instead of requiring you to use str.encode() on them.  It does this by simply checking for string types and converting them during `__init__` of the interface.
+
+### Normalization of Indexing
+I've tried to step through the system and make sure that ranges are used the same everywhere, the relays are 1 indexed (this is not documented in the protocol sheet) so I've tried to make sure all indexing is done correctly vs. a 1 index instead of having to manipulate relay numbers mid code.
+
+## Future Work
+ * Properly formatted output instead of relying solely on log output.
+  * This may actually be easiest to do with a second logger that just handles formatted standard output, this would allow quiet to work relatively trivially.
+ * Refactoring of seq_num updates to easily readable code paths. There's updates in some odd places, they work but they make following code flow difficult.
diff --git a/iboot/iboot.py b/iboot/iboot.py
old mode 100644
new mode 100755
index 97e34f2..a31ef3b
--- a/iboot/iboot.py
+++ b/iboot/iboot.py
@@ -3,9 +3,22 @@
 import logging
 import socket
 import struct
+import sys
+import argparse
+
+logging.getLogger('iBootInterface').addHandler(logging.NullHandler())
 
 HELLO_STR = 'hello-000'
 
+"""struct format:
+little-endian
+unsigned char command
+21 char array username
+21 char array password
+unsigned char description
+unsigned char parameters (should be padding byte or 'B' as unused)
+unsigned short sequence number (uint16) - was H-2byte, set to I-4byte
+"""
 HEADER_STRUCT = struct.Struct('<B21s21sBBH')
 
 COMMAND_MAP = {
@@ -26,9 +39,11 @@ class DXPCommand(object):
     DESCRIPTOR_MAP = None
     DESCRIPTOR = None
     PAYLOAD_STRUCT = None
+    
 
     def __init__(self, interface):
         self.interface = interface
+        self.logger = logging.getLogger('iBootInterface')
 
     def _build_header(self):
         if not self.COMMAND:
@@ -39,7 +54,8 @@ def _build_header(self):
 
         if not self.DESCRIPTOR:
             raise Exception("'DESCRIPTOR' type not specified for class")
-
+        self.logger.debug('dxpcommand.buildheader: COMMANDMAP: ' + str(COMMAND_MAP[self.COMMAND]))
+        self.logger.debug('dxpcommand.buildheader: DESCRIPTORMAP: ' + str(self.DESCRIPTOR_MAP[self.DESCRIPTOR]))
         return HEADER_STRUCT.pack(COMMAND_MAP[self.COMMAND],
                                   self.interface.username,
                                   self.interface.password,
@@ -65,20 +81,26 @@ def _get_boolean_response(self):
             return False
 
         self.interface.increment_seq_num()
+        self.logger.debug('dxpcommand.getboolresponse: responce: ' + str(response))
         return self._parse_bool(response)
 
     def _parse_bool(self, string):
+        self.logger.debug('dxpcommand.parsebool: string: ' + str(string))
         return not struct.unpack('?', string)[0]
 
     def do_request(self):
         header = self._build_header()
+        self.logger.debug('dxpcommand.dorequest: header: ' + str(header))
         payload = self._build_payload()
+        self.logger.debug('dxpcommand.dorequest: payload: ' + str(payload))
         request = header + payload
+        self.logger.debug('dxpcommand.dorequest: fullrequest: ' + str(request))
         self.interface.socket.sendall(request)
         return self._get_response()
 
     def _do_payloadless_request(self):
         request = self._build_header()
+        self.logger.debug('dxpcommand.dopayloadlessrequest: request: ' + str(request))
         self.interface.socket.sendall(request)
         return self._get_response()
 
@@ -97,6 +119,14 @@ class IOCommand(DXPCommand):
     }
 
 
+"""
+Documented relay states:
+NO_CHANGE 0
+ENERGIZE 1
+RELAX 2
+These are incorrect and can not be used, the ones below will function.
+"""
+
 class RelayCommand(IOCommand):
     STATE_MAP = {
         True: 1,
@@ -116,6 +146,7 @@ def __init__(self, interface, relay, state):
         super(ChangeRelayCommand, self).__init__(interface)
         self.relay = relay
         self.state = state
+        self.logger = logging.getLogger('iBootInterface')
 
     def _build_payload(self):
         return super(ChangeRelayCommand, self)._build_payload(
@@ -129,21 +160,23 @@ class ChangeRelaysCommand(RelayCommand):
     def __init__(self, interface, relay_state_dict):
         super(ChangeRelaysCommand, self).__init__(interface)
         self.relay_state_dict = relay_state_dict
+        self.logger = logging.getLogger('iBootInterface')
 
     def _build_payload(self):
         state_list = []
 
-        self.interface.logger.debug(self.relay_state_dict)
-
-        for relay in xrange(32):
-            if (relay + 1) not in self.relay_state_dict:
+        self.logger.debug('changerelaycommand.buildpayload: relaystatedict: ' + str(self.relay_state_dict))
+        
+        """ While not documented, relays are 1 indexed, generate 1-32 indexes"""
+        for relay in range(1,33):
+            if (relay) not in self.relay_state_dict:
                 state_list.append(self.STATE_MAP['NO_CHANGE'])
             else:
                 state_list.append(
-                    self.STATE_MAP[self.relay_state_dict[relay + 1]])
-
-        self.interface.logger.debug(state_list)
+                    self.STATE_MAP[self.relay_state_dict[relay]])
 
+        self.logger.debug('changerelayscommand.buildpayload: state_list: ' + str(state_list))
+        
         return super(ChangeRelaysCommand, self)._build_payload(*state_list)
 
 
@@ -154,13 +187,20 @@ def do_request(self):
         return self._do_payloadless_request()
 
     def _get_response(self):
+        self.logger = logging.getLogger('iBootInterface')
         response = self.interface.socket.recv(self.interface.num_relays)
+        self.logger.debug('getrelayrequest.getresponse: response: ' + str(response))
         if not response:
             return None
-
+        response = struct.unpack("<c",response)
+        self.logger.debug('getrelayrequest.getresponse: response-unpacked: ' + str(response))
         self.interface.increment_seq_num()
-        return [True if ord(relay_status) == 1 else False
-                for relay_status in response]
+        """pre declare dictionary"""
+        relay_dict = {} 
+        for i in range(len(response)):
+          relay_dict[i+1] = (True if int.from_bytes(response[i], byteorder='little')==1 else False)
+        self.logger.debug('getrelayrequest.getresponse: relay_dict: ' + str(relay_dict))
+        return relay_dict
 
 
 class PulseRelayRequest(RelayCommand):
@@ -169,9 +209,13 @@ class PulseRelayRequest(RelayCommand):
 
     def __init__(self, interface, relay, state, width):
         super(PulseRelayRequest, self).__init__(interface)
+        self.logger = logging.getLogger('iBootInterface')
         self.relay = relay
+        self.logger.debug('pulserelayrequest.init.relay: ' + str(self.relay))
         self.state = state
+        self.logger.debug('pulserelayrequest.init.state: ' + str(self.state))
         self.width = width
+        self.logger.debug('pulserelayrequest.init.width: ' + str(self.width))
 
     def _build_payload(self):
         return super(PulseRelayRequest, self)._build_payload(
@@ -181,23 +225,36 @@ def _build_payload(self):
 class iBootInterface(object):
     def __init__(self, ip, username, password, port=9100, num_relays=3):
         self.ip = ip
-        self.username = username
-        self.password = password
+        
+        """
+        there is no auto conversion to bytes type from string
+        if provided as string explicit convert to byte type
+        """
+        if type(username) is str:
+          self.username = str.encode(username)
+        else:
+          self.username = username
+        if type(password) is str:
+          self.password = str.encode(password)
+        else:
+          self.password = password
+        
         self.port = port
         self.num_relays = num_relays
         self.seq_num = None
         self.socket = None
-        logging.basicConfig()
         self.logger = logging.getLogger('iBootInterface')
-        self.logger.setLevel(logging.DEBUG)
+        #self.logger.setLevel(logging.DEBUG)
 
     def get_seq_num(self):
+        self.seq_num += 1 #this seems like the wrong way to do this. sequence numbers should only increment when generating a packet
         seq_num = self.seq_num
-        self.seq_num += 1
+        self.logger.debug('ibootintr.getseqnum: seq_num: ' + str(seq_num))
         return seq_num
 
     def increment_seq_num(self):
         self.seq_num += 1
+        self.logger.debug('ibootintr.incrementseqnum: ' + str(self.seq_num))
 
     def connect(self):
         self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
@@ -206,14 +263,14 @@ def connect(self):
         try:
             self.socket.connect((self.ip, self.port))
         except socket.error:
-            self.logger.error('Socket failed to connect')
+            self.logger.error('ibootintr.connect: Socket failed to connect')
             return False
 
         try:
-            self.socket.sendall(HELLO_STR)
+            self.socket.sendall(str.encode(HELLO_STR))
             return self._get_initial_seq_num()
         except socket.error:
-            self.logger.error('Socket error')
+            self.logger.error('ibootintr.connect: Socket error')
             return False
 
     def _get_initial_seq_num(self):
@@ -221,8 +278,12 @@ def _get_initial_seq_num(self):
 
         if not response:
             return False
+        self.logger.debug('ibootintr.sequencenum_responce:' + str(response) + ' length: ' + str(len(response)))
+        """ should seq_num be auto incremented? seems like it should be
+        done when new packets are issued, not when old ones are captured"""
+        self.seq_num = struct.unpack('<H', response)[0]
 
-        self.seq_num = struct.unpack('H', response)[0] + 1
+        self.logger.debug('ibootintr.getinitialseq - initial sequence:' + str(self.seq_num))
         return True
 
     def disconnect(self):
@@ -255,13 +316,15 @@ def switch_multiple(self, relay_state_dict):
 
         for relay, new_state in relay_state_dict.items():
             request = ChangeRelayCommand(self, relay, new_state)
+            #self.logger.debug('ibootint.switch_multiple: request: ' + str(request))
 
             try:
                 result = request.do_request()
-
+                self.logger.debug('ibootint.switch_multiple: result: ' + str(result))
                 if not result:
                     return False
             except socket.error:
+                self.logger.error('ibootint.switch_multiple: Socket Error')
                 self.disconnect()
                 return False
 
@@ -271,6 +334,7 @@ def switch_multiple(self, relay_state_dict):
     def get_relays(self):
         self.connect()
         request = GetRelaysRequest(self)
+        #self.logger.debug('ibootint.getrelays: request: ' + str(request))
 
         try:
             return request.do_request()
@@ -289,7 +353,119 @@ def pulse_relay(self, relay, on, length):
             return False
         finally:
             self.disconnect()
+            
+"""
+Additions by Garrett McGrath
+"""
+def buildparser():
+  parser=argparse.ArgumentParser(description="ibootpy - iBoot DxP Tool")
+  parser.add_argument("ip", metavar='IP', help="IP you wish to interact with")
+  parser.add_argument("user", metavar='USER', help="User Name",
+		      default="admin", action="store")
+  parser.add_argument("password", metavar='PASSWORD',
+		      default="admin", action="store", help="Device Password")
+  parser.add_argument('action', metavar="ACTION", 
+		      choices=("on","off","toggle","status"), 
+		      default="status", help = 'Action to perform on list of iBoot Devices (default status)')
+  parser.add_argument("--port", help="Port to communicate with device",default=9100,type=int)
+  parser.add_argument("--relays", help="Number of relays to interact with", default=1,type=int)
+  
+
+  #Add controls for 
+
+  parser.add_argument("-v","--verbose", help="verbose output (currently unimplemented)", action="store_true")
+  parser.add_argument("-q","--quiet", help="silence output, simply return success or failure.", action="store_true")
+  parser.add_argument("--debug", help="Enable Debug Output", action="store_true")
+  parser.add_argument("--legacy", help="This outputs an 'on/off' note compatible with the old perl package for rev 1 iboots. This status is based off the value of relay 1 as the gen 1 iboots were single relay devices.", action="store_true")
+  
+  return parser
+  
+            
+def run(args=None):
+
+  """Main entry if running as commandline program"""
+
+  parser = buildparser()
+  args = parser.parse_args()
+
+  """
+  configure logging to print to stderr
+  """
+  
+  #grab iboot logger
+  logger = logging.getLogger('iBootInterface')
+  
+  #create format info
+  FORMAT = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+  formatter = logging.Formatter(FORMAT)
+  
+  #configure stdout based handler
+  shandler = logging.StreamHandler(sys.stdout)
+  shandler.setFormatter(formatter)
+
+  logger.setLevel(logging.INFO)
+
+  if args.debug:
+    logger.setLevel(logging.DEBUG)
+  
+  #only add handling for output if the quiet flag isn't set
+  if not args.quiet:
+    logger.addHandler(shandler)
+  
+
+  dev = iBootInterface(args.ip, args.user, args.password, args.port, args.relays)
+  
+  """effectively a case statement for requested actions
+  extremely rudimentary at this point, no sanity checking included."""
+  relays = {}
+  if args.action == "status":
+    relays=dev.get_relays()
+    logger.info('status: ' + str(relays))
+  elif args.action == "on":
+    relays=dev.get_relays()
+    logger.info('on_start: ' + str(relays))
+    for relay in relays:
+      relays[relay] = True
+    logger.info('on_sending: ' + str(relays))
+    dev.switch_multiple(relays)
+    relays=dev.get_relays()
+    logger.info('on_end: ' + str(relays))
+    
+  elif args.action == "off":
+    relays=dev.get_relays()
+    logger.info('off_start: ' + str(relays))
+    for relay in relays:
+      relays[relay] = False
+    logger.info('off_sending: ' + str(relays))
+    dev.switch_multiple(relays)
+    relays=dev.get_relays()
+    logger.info('off_end: ' + str(relays))
+    
+  elif args.action == "toggle":
+    relays=dev.get_relays()
+    logger.info('toggle_start: ' + str(relays))    
+    for relay in relays:
+      relays[relay] = not relays[relay]
+    logger.info('toggle_sending: ' + str(relays))  
+    dev.switch_multiple(relays)
+    relays=dev.get_relays()
+    logger.info('toggle_end: ' + str(relays))
+    
+  else:
+    logger.info("invalid state request")
+  
+  """ Print on/off for legacy output """
+  if args.legacy:
+    if relays[1]:
+      print ('ON')
+    else:
+      print ('OFF')
+  
+  
+  return 0
+  
+  
 
 if __name__ == '__main__':
-    interface = iBootInterface('192.168.0.105', 'admin', 'admin')
 
+  sys.exit(run())
\ No newline at end of file
diff --git a/setup.py b/setup.py
old mode 100644
new mode 100755
index 25d5d8e..1cd2b84
--- a/setup.py
+++ b/setup.py
@@ -15,4 +15,9 @@
         "Topic :: Utilities",
         "License :: OSI Approved :: BSD License",
     ],
+    entry_points = {
+      'console_scripts':[
+      'ibootpy = iboot.iboot:run',
+      ]
+    },
 )