diff --git a/.gitignore b/.gitignore
new file mode 100755
index 0000000000000000000000000000000000000000..23b482c06635f3449910375622d0b1b7312a897d_LmdpdGlnbm9yZQ==
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,59 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.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
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*,cover
+.hypothesis/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
diff --git a/EMCUnity/Unity.py b/EMCUnity/Unity.py
new file mode 100755
index 0000000000000000000000000000000000000000..23b482c06635f3449910375622d0b1b7312a897d_RU1DVW5pdHkvVW5pdHkucHk=
--- /dev/null
+++ b/EMCUnity/Unity.py
@@ -0,0 +1,765 @@
+import requests
+import json
+from . import UnityClasses
+from .UnityClasses import *
+
+requests.packages.urllib3.disable_warnings()
+
+class Unity:
+    """ Class representing an EMC Unity Array """
+
+    def __init__(self, ip_addr, username, password):
+        self.ip_addr = ip_addr
+        self.username = username
+        self.password = password
+        self.is_auth = False
+        self.api_url = 'https://%s/api' % self.ip_addr
+
+        self.headers = {'Accept':'application/json',
+                        'Content-type':'application/json',
+                        'X-EMC-REST-CLIENT':'true'}
+
+        self.session = requests.Session()
+
+        sys_info = self.unity_request('/instances/basicSystemInfo/0').json()
+        self.name = sys_info['content']['name']
+        self.model = sys_info['content']['model']
+        self.software = sys_info['content']['softwareVersion']
+
+    def process_response(self, response):
+        """ Process the HTTPS response and set headers or raise exceptions """
+        # TODO: work with Exceptions for easier troubleshooting
+        response.raise_for_status()
+
+        if 'EMC-CSRF-TOKEN' not in self.headers:
+            self.headers['EMC-CSRF-TOKEN'] = response.headers.get('emc-csrf-token')
+
+        if self.headers['EMC-CSRF-TOKEN']:
+            self.is_auth = True
+
+        return
+
+    def get_from_type(self, url_path, object_type, payload = None):
+        """
+        Performs a request of all fields for a given object_type unless
+        specific fields have been requested as part of the payload
+        """
+
+        def process(content):
+            """Warn about additions to the REST API"""
+            try:
+                obj = object_type(**content)
+            except TypeError:
+                good, bad = {}, {}
+                for key, value in list(content.items()):
+                    if key in object_type._fields:
+                        good[key] = value
+                    else:
+                        bad[key] = value
+                from warnings import warn
+                warn('Unity REST API call returned unexpected fields: %r' % bad,
+                    RuntimeWarning, stacklevel=3)
+                obj = object_type(**good)
+            return obj
+
+        if not payload:
+            payload = dict()
+
+        if 'fields' not in payload:
+            payload['fields'] = ",".join(object_type._fields)
+
+        response = self.unity_request(url_path, 'GET', payload = payload).json()
+
+        if 'entries' in response:
+            returned_items = []
+            for item in response['entries']:
+                returned_items.append(process(item['content']))
+            return returned_items
+
+        elif 'content' in response:
+            return process(response['content'])
+
+        else:
+            return None
+
+    def unity_request(self, url_path, method = 'GET', payload = None):
+        """ Perform a request to the Unity array """
+
+        if not payload:
+            payload = dict()
+
+        url = self.api_url + url_path
+
+        if method == 'GET':
+            request_function = self.session.get
+        elif method == 'POST':
+            request_function = self.session.post
+        elif method == 'DELETE':
+            request_function = self.session.delete
+        else:
+            return None
+
+        if method != 'POST':
+            if self.is_auth:
+                response = request_function(url, verify = False,
+                                            headers = self.headers,
+                                            params = payload)
+            else:
+                response = request_function(url, verify = False,
+                                            auth = (self.username, self.password),
+                                            headers = self.headers,
+                                            params = payload)
+        else: # For POST requests, we pass data, not payload
+            payload = json.dumps(payload)
+            if self.is_auth:
+                response = request_function(url, verify = False,
+                                            headers = self.headers,
+                                            data = payload)
+            else:
+                response = request_function(url, verify = False,
+                                            auth = (self.username, self.password),
+                                            headers = self.headers,
+                                            data = payload)
+
+        self.process_response(response)
+
+        return response
+
+    def get(self, url_path, payload = None):
+        """ Wrapper for performing a GET unity request """
+        return self.unity_request(url_path, method='GET', payload = payload)
+
+    def post(self, url_path, payload = None):
+        """ Wrapper for performing a POST unity request """
+        return self.unity_request(url_path, method='POST', payload = payload)
+
+    def delete(self, url_path, payload = None):
+        """ Wrapper for performing a DELETE unity request """
+        return self.unity_request(url_path, method='DELETE', payload = payload)
+
+    def get_object(self, unity_type, item_filter = None, item_id=None, item_name=None):
+        """ Get an object (singular or a collection) """
+
+        payload = dict()
+
+        # Take the unity_type string passed in and determine the actual object
+        unity_object = getattr(UnityClasses, "Unity%s" % unity_type)
+
+        if item_filter:
+            payload['filter'] = item_filter
+
+        if not item_id and not item_name: # Request is for all objects
+            response = self.get_from_type('/types/%s/instances' % unity_type, unity_object, payload = payload)
+            return response
+
+        if item_id:  # Request is for a specific ID
+            response = self.get_from_type('/instances/%s/%s' % (unity_type, item_id), unity_object, payload = payload)
+        elif item_name: # Request is for a specific name
+            if 'filter' in payload:
+                payload['filter'] = payload['filter'] + ' && name eq "%s"' % item_name
+            else:
+                payload['filter'] = 'name eq "%s"' % item_name
+
+            response = self.get_from_type('/types/%s/instances' % unity_type, unity_object, payload = payload)
+
+        return response
+
+    # Network communications
+    # -----------------------------------------
+    def cifsServer(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('cifsServer', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def dnsServer(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('dnsServer', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def fileDNSServer(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('fileDNSServer', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def fileInterface(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('fileInterface', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def fileKerberosServer(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('fileKerberosServer', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def fileLDAPServer(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('fileLDAPServer', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def fileNDMPServer(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('fileNDMPServer', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def fileNISServer(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('fileNISServer', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def ftpServer(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('ftpServer', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def ipInterface(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('ipInterface', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def ipPort(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('ipPort', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def iscsiNode(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('iscsiNode', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def iscsiPortal(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('iscsiPortal', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def iscsiSettings(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('iscsiSettings', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def linkAggregation(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('linkAggregation', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def mgmtInterface(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('mgmtInterface', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def mgmtInterfaceSettings(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('mgmtInterfaceSettings', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def nasServer(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('nasServer', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def nfsServer(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('nfsServer', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def preferredInterfaceSettings(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('preferredInterfaceSettings', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def route(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('route', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def smtpServer(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('smtpServer', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def urServer(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('urServer', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def virusChecker(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('virusChecker', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def vmwareNasPEServer(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('vmwareNasPEServer', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    # Events and Alerts
+    # -----------------------------------------
+    def alert(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('alert', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def alertConfig(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('alertConfig', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def alertConfigSNMPTarget(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('alertConfigSNMPTarget', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def event(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('event', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    # Jobs
+    # -----------------------------------------
+    def job(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('job', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    # Remote Systems
+    # -----------------------------------------
+    def cifsShare(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('cifsShare', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def datastore(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('datastore', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def host(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('host', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def hostContainer(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('hostContainer', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def hostIPPort(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('hostIPPort', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def hostInitiator(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('hostInitiator', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def hostInitiatorPath(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('hostInitiatorPath', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def hostLUN(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('hostLUN', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def hostVVolDatastore(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('hostVVolDatastore', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def nfsShare(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('nfsShare', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def remoteSystem(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('remoteSYstem', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def rpChapSettings(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('rpChapSettings', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def vm(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('vm', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def vmDisk(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('vmDisk', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def vmwarePE(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('vmwarePE', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    # Storage Management
+    # -----------------------------------------
+    def aclUser(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('aclUser', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def capabilityProfile(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('capabilityProfile', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def dhsmServer(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('dhsmServer', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def diskGroup(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('diskGroup', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def fastCache(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('fastCache', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def fastVP(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('fastVP', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def filesystem(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('filesystem', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def lun(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('lun', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def pool(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('pool', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def poolConsumer(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('poolConsumer', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def poolConsumerAllocation(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('poolConsumerAllocation', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def poolUnit(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('poolUnit', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def quotaConfig(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('quotaConfig', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def raidGroup(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('raidGroup', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def storageResource(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('storageResource', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def storageResourceCapabilityProfile(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('storageResourceCapabilityProfile', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def storageTier(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('storageTier', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def treeQuota(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('treeQuota', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def userQuota(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('userQuota', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def virtualVolume(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('virtualVolume', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    # Environment Management
+    # -----------------------------------------
+    def battery(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('battery', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def dae(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('dae', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def disk(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('disk', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def dpe(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('dpe', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def encryption(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('encryption', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def ethernetPort(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('ethernetPort', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def fan(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('fan', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def fcPort(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('fcPort', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def ioModule(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('ioModule', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def lcc(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('lcc', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def memoryModule(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('memoryModule', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def powerSupply(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('powerSupply', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def sasPort(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('sasPort', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def ssc(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('ssc', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def ssd(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('ssd', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def storageProcessor(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('storageProcessor', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def uncommittedPort(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('uncommittedPort', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    # Managing the System
+    # -----------------------------------------
+    def basicSystemInfo(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('basicSystemInfo', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def candidateSoftwareVersion(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('candidateSoftwareVersion', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def feature(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('feature', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def installedSoftwareVersion(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('installedSoftwareVersion', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def license(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('license', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+    def ntpServer(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('ntpServer', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def remoteSyslog(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('remoteSyslog', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def serviceContract(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('serviceContract', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def softwareUpgradeSession(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('softwareUpgradeSession', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def system(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('system', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def systemInformation(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('systemInformation', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def systemLimit(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('systemLimit', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def systemTime(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('systemTime', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    # Monitoring capacity and performance
+    # -----------------------------------------
+    def metric(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('metric', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def metricCollection(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('metricCollection', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def metricQueryResult(self, item_filter = None, item_id=None, item_name=None):
+        """ metricQueryResult is an odd request, as it REQUIRES a specific filter
+            to be passed to it.  For the user, we're taking that as either a part
+            of the filter, or we're creating the filter for them """
+
+        if item_id:
+            if "queryId" not in item_filter:
+                if item_filter:
+                    item_filter = "queryId EQ %s && %s" % (item_id, item_filter)
+                else:
+                    item_filter = "queryId EQ %s" % item_id
+
+        if "queryId" not in item_filter:
+            # TODO, we really should throw an exception here
+            return None
+
+        return self.get_object('metricQueryResult', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def metricRealTimeQuery(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('metricRealTimeQuery', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def metricService(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('metricService', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def metricValue(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('metricValue', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    # Protecting Data
+    # -----------------------------------------
+    def ldapServer(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('ldapServer', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def remoteInterface(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('remoteInterface', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def replicationInterface(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('replicationInterface', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def replicationSession(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('replicationSession', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def snap(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('snap', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def snapSchedule(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('snapSchedule', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    # Quality of Service
+    # -----------------------------------------
+    def ioLimitPolicy(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('ioLimitPolicy', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def ioLimitRule(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('ioLimitRule', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def ioLimitSetting(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('ioLimitSetting', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    # Servicing the System
+    # -----------------------------------------
+    def configCaptureResult(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('configCaptureResult', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def dataCollectionResult(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('dataCollectionResult', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def esrsParam(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('esrsParam', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def esrsPolicymanager(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('esrsPolicymanager', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def serviceAction(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('serviceAction', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def serviceInfo(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('serviceInfo', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def supportAsset(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('supportAsset', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def supportService(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('supportService', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def technicalAdvisory(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('technicalAdvisory', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    # Users and Security
+    # -----------------------------------------
+    def crl(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('crl', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def loginSessionInfo(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('loginSessionInfo', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def role(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('role', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def roleMapping(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('roleMapping', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def securitySettings(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('securitySettings', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def user(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('user', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    def x509Certificate(self, item_filter = None, item_id=None, item_name=None):
+        return self.get_object('x509Certificate', item_filter=item_filter,
+                               item_id=item_id, item_name=item_name)
+
+    # Helper Functions
+    # -----------------------------------------
+    def delete_storageResource(self, lun_id):
+        response = self.delete('/instances/storageResource/%s' % lun_id)
+        return response
+
+    def delete_lun(self, lun_id):
+        """ Deletes a LUN based on the lun_id """
+        response = self.delete_storageResource(lun_id)
+        return response
+
+    def create_lun(self, lun_name, pool_id, size, lun_description=None):
+        """ Creates a new block LUN in pool_id, returns a lun object """
+        payload = {'name':lun_name,
+                   'lunParameters':{'pool':{'id':pool_id},
+                   'size':size}}
+
+        response = self.post('/types/storageResource/action/createLun', payload)
+
+        new_id = response.json()['content']['storageResource']['id']
+        return self.lun(item_id=new_id)
+
+    def create_lun_from_obj(self, lun_object):
+        """ Creates a new block LUN based on a lun_object being passed """
+        payload = {'name': lun_object.name,
+                   'lunParameters':{'pool':{'id':lun_object.pool},
+                                    'size': lun_object.sizeTotal}}
+
+        response = self.post('/types/storageResource/action/createLun', payload)
+
+        new_id = response.json()['content']['storageResource']['id']
+        return self.lun(item_id=new_id)
+
+    def create_vmware_lun_from_obj(self, lun_object):
+        """ Creates a new block LUN based on a lun_object being passed """
+        payload = {'name': lun_object.name,
+                   'lunParameters':{'pool':{'id':lun_object.pool},
+                                    'size': lun_object.sizeTotal}}
+        print(payload)
+        response = self.post('/types/storageResource/action/createVmwareLun', payload)
+
+        new_id = response.json()['content']['storageResource']['id']
+        return self.lun(item_id=new_id)
+
+    def create_vmware_lun(self, lun_name, pool_id, size, lun_description=None):
+        """ Creates a new block LUN in pool_id, returns a lun object """
+        payload = {'name':lun_name,
+                   'lunParameters':{'pool':{'id':pool_id},
+                   'size':size}}
+
+        response = self.post('/types/storageResource/action/createVmwareLun', payload)
+
+        new_id = response.json()['content']['storageResource']['id']
+        return self.lun(item_id=new_id)
+
+    def __repr__(self):
+        return "<Unity Array: %s>" % self.ip_addr
diff --git a/EMCUnity/UnityClasses.py b/EMCUnity/UnityClasses.py
new file mode 100755
index 0000000000000000000000000000000000000000..23b482c06635f3449910375622d0b1b7312a897d_RU1DVW5pdHkvVW5pdHlDbGFzc2VzLnB5
--- /dev/null
+++ b/EMCUnity/UnityClasses.py
@@ -0,0 +1,1880 @@
+import collections
+
+
+def namedtuple_defaults(typename, field_names, default_values=()):
+    ''' This makes our objects simple named tuples with default values of None
+        standard namedtuples, require all values '''
+    T = collections.namedtuple(typename, field_names)
+    T.__new__.__defaults__ = (None,) * len(T._fields)
+    if isinstance(default_values, collections.abc.Mapping):
+        prototype = T(**default_values)
+    else:
+        prototype = T(*default_values)
+    T.__new__.__defaults__ = tuple(prototype)
+    return T
+
+UnityaclUser = namedtuple_defaults('UnityaclUser', [
+                                                    'id',
+                                                    'sid',
+                                                    'domainName',
+                                                    'userName',
+                                                    ])
+
+
+Unityalert = namedtuple_defaults('Unityalert', [
+                                                'id',
+                                                'timestamp',
+                                                'severity',
+                                                'component',
+                                                'messageId',
+                                                'message',
+                                                'descriptionId',
+                                                'description',
+                                                'resolutionId',
+                                                'resolution',
+                                                'isAcknowledged',
+                                                ])
+
+
+UnityalertConfig = namedtuple_defaults('UnityalertConfig', [
+                                                            'id',
+                                                            'locale',
+                                                            'isThresholdAlertsEnabled',
+                                                            'minEmailNotificationSeverity',
+                                                            'destinationEmails',
+                                                            'minSNMPTrapNotificationSeverity',
+                                                            ])
+
+
+UnityalertConfigSNMPTarget = namedtuple_defaults('UnityalertConfigSNMPTarget', [
+                                                                                'id',
+                                                                                'address',
+                                                                                'version',
+                                                                                'username',
+                                                                                'authProto',
+                                                                                'privacyProto',
+                                                                                ])
+
+
+UnitybaseRequest = namedtuple_defaults('UnitybaseRequest', [
+                                                            ])
+
+
+UnitybaseResponse = namedtuple_defaults('UnitybaseResponse', [
+                                                              ])
+
+
+UnitybasicSystemInfo = namedtuple_defaults('UnitybasicSystemInfo', [
+                                                                    'id',
+                                                                    'model',
+                                                                    'name',
+                                                                    'softwareVersion',
+                                                                    'softwareFullVersion',
+                                                                    'apiVersion',
+                                                                    'earliestApiVersion',
+                                                                    ])
+
+
+Unitybattery = namedtuple_defaults('Unitybattery', [
+                                                    'id',
+                                                    'health',
+                                                    'needsReplacement',
+                                                    'parent',
+                                                    'slotNumber',
+                                                    'name',
+                                                    'manufacturer',
+                                                    'model',
+                                                    'firmwareVersion',
+                                                    'emcPartNumber',
+                                                    'emcSerialNumber',
+                                                    'vendorPartNumber',
+                                                    'vendorSerialNumber',
+                                                    'parentStorageProcessor',
+                                                    ])
+
+
+UnityblockHostAccess = namedtuple_defaults('UnityblockHostAccess', [
+                                                                    'host',
+                                                                    'accessMask',
+                                                                    ])
+
+
+UnitycandidateSoftwareVersion = namedtuple_defaults('UnitycandidateSoftwareVersion', [
+                                                                                      'id',
+                                                                                      'version',
+                                                                                      'revision',
+                                                                                      'releaseDate',
+                                                                                      'type',
+                                                                                      ])
+
+
+UnitycapabilityProfile = namedtuple_defaults('UnitycapabilityProfile', [
+                                                                        'id',
+                                                                        'vmwareUUID',
+                                                                        'name',
+                                                                        'description',
+                                                                        'pool',
+                                                                        'driveTypes',
+                                                                        'fastCacheStates',
+                                                                        'raidTypes',
+                                                                        'spaceEfficiencies',
+                                                                        'tieringPolicies',
+                                                                        'serviceLevels',
+                                                                        'usageTags',
+                                                                        'inUse',
+                                                                        'health',
+                                                                        'virtualVolumes',
+                                                                        ])
+
+
+UnitycertificateScope = namedtuple_defaults('UnitycertificateScope', [
+                                                                      'nasServer',
+                                                                      ])
+
+
+UnitycifsServer = namedtuple_defaults('UnitycifsServer', [
+                                                          'id',
+                                                          'name',
+                                                          'description',
+                                                          'netbiosName',
+                                                          'domain',
+                                                          'lastUsedOrganizationalUnit',
+                                                          'workgroup',
+                                                          'isStandalone',
+                                                          'health',
+                                                          'nasServer',
+                                                          'fileInterfaces',
+                                                          'smbcaSupported',
+                                                          'smbMultiChannelSupported',
+                                                          'smbProtocolVersions',
+                                                          ])
+
+
+UnitycifsShare = namedtuple_defaults('UnitycifsShare', [
+                                                        'id',
+                                                        'type',
+                                                        'filesystem',
+                                                        'snap',
+                                                        'isReadOnly',
+                                                        'name',
+                                                        'path',
+                                                        'exportPaths',
+                                                        'description',
+                                                        'creationTime',
+                                                        'modifiedTime',
+                                                        'isContinuousAvailabilityEnabled',
+                                                        'isEncryptionEnabled',
+                                                        'isACEEnabled',
+                                                        'isABEEnabled',
+                                                        'isBranchCacheEnabled',
+                                                        'isDFSEnabled',
+                                                        'offlineAvailability',
+                                                        'umask',
+                                                        ])
+
+
+UnitycifsShareACE = namedtuple_defaults('UnitycifsShareACE', [
+                                                              'sid',
+                                                              'accessType',
+                                                              'accessLevel',
+                                                              ])
+
+
+UnityconfigCaptureResult = namedtuple_defaults('UnityconfigCaptureResult', [
+                                                                            'id',
+                                                                            'name',
+                                                                            'creationTime',
+                                                                            ])
+
+
+Unitycrl = namedtuple_defaults('Unitycrl', [
+                                            'id',
+                                            'service',
+                                            'scope',
+                                            'version',
+                                            'crlNumber',
+                                            'signatureAlgorithm',
+                                            'issuer',
+                                            'thisUpdate',
+                                            'nextUpdate',
+                                            'certificates',
+                                            'deltaCRLIndicator',
+                                            ])
+
+
+Unitydae = namedtuple_defaults('Unitydae', [
+                                            'id',
+                                            'health',
+                                            'needsReplacement',
+                                            'parent',
+                                            'slotNumber',
+                                            'name',
+                                            'manufacturer',
+                                            'model',
+                                            'emcPartNumber',
+                                            'emcSerialNumber',
+                                            'vendorPartNumber',
+                                            'vendorSerialNumber',
+                                            'enclosureType',
+                                            'busId',
+                                            'driveTypes',
+                                            'currentPower',
+                                            'avgPower',
+                                            'maxPower',
+                                            'currentTemperature',
+                                            'avgTemperature',
+                                            'maxTemperature',
+                                            'currentSpeed',
+                                            'maxSpeed',
+                                            'parentSystem',
+                                            ])
+
+
+UnitydataCollectionResult = namedtuple_defaults('UnitydataCollectionResult', [
+                                                                              'id',
+                                                                              'name',
+                                                                              'creationTime',
+                                                                              ])
+
+
+Unitydatastore = namedtuple_defaults('Unitydatastore', [
+                                                        'id',
+                                                        'storageResource',
+                                                        'name',
+                                                        'format',
+                                                        'host',
+                                                        'sizeTotal',
+                                                        'sizeUsed',
+                                                        'vmDisks',
+                                                        'vms',
+                                                        ])
+
+
+UnitydhsmServer = namedtuple_defaults('UnitydhsmServer', [
+                                                          'id',
+                                                          'nasServer',
+                                                          'username',
+                                                          ])
+
+
+Unitydisk = namedtuple_defaults('Unitydisk', [
+                                              'id',
+                                              'health',
+                                              'needsReplacement',
+                                              'parent',
+                                              'slotNumber',
+                                              'busId',
+                                              'name',
+                                              'manufacturer',
+                                              'model',
+                                              'version',
+                                              'emcPartNumber',
+                                              'emcSerialNumber',
+                                              'tierType',
+                                              'diskGroup',
+                                              'rpm',
+                                              'isSED',
+                                              'currentSpeed',
+                                              'maxSpeed',
+                                              'pool',
+                                              'isInUse',
+                                              'isFastCacheInUse',
+                                              'size',
+                                              'rawSize',
+                                              'vendorSize',
+                                              'wwn',
+                                              'diskTechnology',
+                                              'parentDae',
+                                              'parentDpe',
+                                              'bank',
+                                              'bankSlotNumber',
+                                              'bankSlot',
+                                              ])
+
+
+UnitydiskGroup = namedtuple_defaults('UnitydiskGroup', [
+                                                        'id',
+                                                        'name',
+                                                        'emcPartNumber',
+                                                        'tierType',
+                                                        'diskTechnology',
+                                                        'isFASTCacheAllowable',
+                                                        'diskSize',
+                                                        'advertisedSize',
+                                                        'rpm',
+                                                        'speed',
+                                                        'totalDisks',
+                                                        'minHotSpareCandidates',
+                                                        'hotSparePolicyStatus',
+                                                        'unconfiguredDisks',
+                                                        ])
+
+
+UnitydnsServer = namedtuple_defaults('UnitydnsServer', [
+                                                        'id',
+                                                        'domain',
+                                                        'addresses',
+                                                        'origin',
+                                                        ])
+
+
+Unitydpe = namedtuple_defaults('Unitydpe', [
+                                            'id',
+                                            'health',
+                                            'needsReplacement',
+                                            'parent',
+                                            'slotNumber',
+                                            'name',
+                                            'manufacturer',
+                                            'model',
+                                            'emcPartNumber',
+                                            'emcSerialNumber',
+                                            'vendorPartNumber',
+                                            'vendorSerialNumber',
+                                            'enclosureType',
+                                            'busId',
+                                            'driveTypes',
+                                            'currentPower',
+                                            'avgPower',
+                                            'maxPower',
+                                            'currentTemperature',
+                                            'avgTemperature',
+                                            'maxTemperature',
+                                            'currentSpeed',
+                                            'maxSpeed',
+                                            'parentSystem',
+                                            ])
+
+
+Unityencryption = namedtuple_defaults('Unityencryption', [
+                                                          'id',
+                                                          'encryptionMode',
+                                                          'encryptionStatus',
+                                                          'encryptionPercentage',
+                                                          'keyManagerBackupKeyStatus',
+                                                          ])
+
+
+UnityesrsParam = namedtuple_defaults('UnityesrsParam', [
+                                                        'id',
+                                                        'enabled',
+                                                        'isCentralized',
+                                                        'status',
+                                                        'proxyIsEnabled',
+                                                        'proxyAddress',
+                                                        'proxyIsHTTP',
+                                                        'proxyUserName',
+                                                        'esrsVeAddress',
+                                                        'siteId',
+                                                        'esrsConfigStatus',
+                                                        'isEsrsVeEulaAccepted',
+                                                        ])
+
+
+UnityesrsPolicyManager = namedtuple_defaults('UnityesrsPolicyManager', [
+                                                                        'id',
+                                                                        'isEnabled',
+                                                                        'address',
+                                                                        'useHTTPS',
+                                                                        'sslStrength',
+                                                                        'proxyIsEnabled',
+                                                                        'proxyAddress',
+                                                                        'proxyUseSocks',
+                                                                        'proxyUserName',
+                                                                        ])
+
+
+UnityethernetPort = namedtuple_defaults('UnityethernetPort', [
+                                                              'id',
+                                                              'health',
+                                                              'storageProcessor',
+                                                              'needsReplacement',
+                                                              'name',
+                                                              'portNumber',
+                                                              'speed',
+                                                              'mtu',
+                                                              'connectorType',
+                                                              'bond',
+                                                              'isLinkUp',
+                                                              'macAddress',
+                                                              'isRSSCapable',
+                                                              'isRDMACapable',
+                                                              'requestedSpeed',
+                                                              'parentIOModule',
+                                                              'parentStorageProcessor',
+                                                              'supportedSpeeds',
+                                                              'requestedMtu',
+                                                              'supportedMtus',
+                                                              'parent',
+                                                              'sfpSupportedSpeeds',
+                                                              'sfpSupportedProtocols',
+                                                              ])
+
+
+Unityevent = namedtuple_defaults('Unityevent', [
+                                                'id',
+                                                'node',
+                                                'creationTime',
+                                                'severity',
+                                                'messageId',
+                                                'arguments',
+                                                'message',
+                                                'username',
+                                                'category',
+                                                'source',
+                                                ])
+
+
+Unityfan = namedtuple_defaults('Unityfan', [
+                                            'id',
+                                            'health',
+                                            'parent',
+                                            'slotNumber',
+                                            'name',
+                                            'emcPartNumber',
+                                            'emcSerialNumber',
+                                            'manufacturer',
+                                            'model',
+                                            'vendorPartNumber',
+                                            'vendorSerialNumber',
+                                            'needsReplacement',
+                                            'parentDpe',
+                                            'parentDae',
+                                            ])
+
+
+UnityfastCache = namedtuple_defaults('UnityfastCache', [
+                                                        'id',
+                                                        'health',
+                                                        'sizeTotal',
+                                                        'sizeFree',
+                                                        'numberOfDisks',
+                                                        'raidLevel',
+                                                        'raidGroups',
+                                                        ])
+
+
+UnityfastVP = namedtuple_defaults('UnityfastVP', [
+                                                  'id',
+                                                  'status',
+                                                  'relocationRate',
+                                                  'isScheduleEnabled',
+                                                  'scheduleDays',
+                                                  'scheduleStartTime',
+                                                  'scheduleEndTime',
+                                                  'sizeMovingDown',
+                                                  'sizeMovingUp',
+                                                  'sizeMovingWithin',
+                                                  'relocationDurationEstimate',
+                                                  ])
+
+
+UnityfcPort = namedtuple_defaults('UnityfcPort', [
+                                                  'id',
+                                                  'health',
+                                                  'parent',
+                                                  'slotNumber',
+                                                  'wwn',
+                                                  'availableSpeeds',
+                                                  'currentSpeed',
+                                                  'requestedSpeed',
+                                                  'sfpSupportedSpeeds',
+                                                  'sfpSupportedProtocols',
+                                                  'connectorType',
+                                                  'storageProcessor',
+                                                  'needsReplacement',
+                                                  'nPortId',
+                                                  'name',
+                                                  'parentIOModule',
+                                                  'parentStorageProcessor',
+                                                  ])
+
+
+Unityfeature = namedtuple_defaults('Unityfeature', [
+                                                    'id',
+                                                    'name',
+                                                    'state',
+                                                    'reason',
+                                                    'license',
+                                                    ])
+
+
+UnityfileDNSServer = namedtuple_defaults('UnityfileDNSServer', [
+                                                                'id',
+                                                                'nasServer',
+                                                                'addresses',
+                                                                'domain',
+                                                                'replicationPolicy',
+                                                                'sourceParameters',
+                                                                ])
+
+
+UnityfileInterface = namedtuple_defaults('UnityfileInterface', [
+                                                                'id',
+                                                                'nasServer',
+                                                                'ipPort',
+                                                                'health',
+                                                                'ipAddress',
+                                                                'ipProtocolVersion',
+                                                                'netmask',
+                                                                'v6PrefixLength',
+                                                                'gateway',
+                                                                'vlanId',
+                                                                'macAddress',
+                                                                'name',
+                                                                'role',
+                                                                'isPreferred',
+                                                                'replicationPolicy',
+                                                                'sourceParameters',
+                                                                'isDisabled',
+                                                                ])
+
+
+UnityfileKerberosServer = namedtuple_defaults('UnityfileKerberosServer', [
+                                                                          'id',
+                                                                          'nasServer',
+                                                                          'realm',
+                                                                          'addresses',
+                                                                          'portNumber',
+                                                                          ])
+
+
+UnityfileLDAPServer = namedtuple_defaults('UnityfileLDAPServer', [
+                                                                  'id',
+                                                                  'nasServer',
+                                                                  'authority',
+                                                                  'profileDN',
+                                                                  'serverAddresses',
+                                                                  'portNumber',
+                                                                  'authenticationType',
+                                                                  'protocol',
+                                                                  'verifyServerCertificate',
+                                                                  'bindDN',
+                                                                  'isCifsAccountUsed',
+                                                                  'principal',
+                                                                  'realm',
+                                                                  'schemeType',
+                                                                  'replicationPolicy',
+                                                                  'sourceParameters',
+                                                                  ])
+
+
+UnityfileNDMPServer = namedtuple_defaults('UnityfileNDMPServer', [
+                                                                  'id',
+                                                                  'nasServer',
+                                                                  'username',
+                                                                  ])
+
+
+UnityfileNISServer = namedtuple_defaults('UnityfileNISServer', [
+                                                                'id',
+                                                                'nasServer',
+                                                                'addresses',
+                                                                'domain',
+                                                                'replicationPolicy',
+                                                                'sourceParameters',
+                                                                ])
+
+
+Unityfilesystem = namedtuple_defaults('Unityfilesystem', [
+                                                          'id',
+                                                          'health',
+                                                          'name',
+                                                          'description',
+                                                          'type',
+                                                          'sizeTotal',
+                                                          'sizeUsed',
+                                                          'sizeAllocated',
+                                                          'isReadOnly',
+                                                          'isThinEnabled',
+                                                          'storageResource',
+                                                          'isCIFSSyncWritesEnabled',
+                                                          'pool',
+                                                          'isCIFSOpLocksEnabled',
+                                                          'nasServer',
+                                                          'isCIFSNotifyOnWriteEnabled',
+                                                          'isCIFSNotifyOnAccessEnabled',
+                                                          'cifsNotifyOnChangeDirDepth',
+                                                          'tieringPolicy',
+                                                          'supportedProtocols',
+                                                          'metadataSize',
+                                                          'metadataSizeAllocated',
+                                                          'perTierSizeUsed',
+                                                          'snapsSize',
+                                                          'snapsSizeAllocated',
+                                                          'snapCount',
+                                                          'isSMBCA',
+                                                          'accessPolicy',
+                                                          'format',
+                                                          'hostIOSize',
+                                                          'poolFullPolicy',
+                                                          'cifsShare',
+                                                          'nfsShare',
+                                                          ])
+
+
+UnityftpServer = namedtuple_defaults('UnityftpServer', [
+                                                        'id',
+                                                        'nasServer',
+                                                        'isFtpEnabled',
+                                                        'isSftpEnabled',
+                                                        'isCifsUserEnabled',
+                                                        'isUnixUserEnabled',
+                                                        'isAnonymousUserEnabled',
+                                                        'isHomedirLimitEnabled',
+                                                        'defaultHomedir',
+                                                        'welcomeMsg',
+                                                        'motd',
+                                                        'isAuditEnabled',
+                                                        'auditDir',
+                                                        'auditMaxSize',
+                                                        'hostsList',
+                                                        'usersList',
+                                                        'groupsList',
+                                                        'isAllowHost',
+                                                        'isAllowUser',
+                                                        'isAllowGroup',
+                                                        ])
+
+
+Unityhealth = namedtuple_defaults('Unityhealth', [
+                                                  'value',
+                                                  'descriptionIds',
+                                                  'descriptions',
+                                                  'resolutionIds',
+                                                  'resolutions',
+                                                  ])
+
+
+Unityhost = namedtuple_defaults('Unityhost', [
+                                              'id',
+                                              'health',
+                                              'name',
+                                              'description',
+                                              'type',
+                                              'osType',
+                                              'hostUUID',
+                                              'hostPushedUUID',
+                                              'hostPolledUUID',
+                                              'lastPollTime',
+                                              'autoManageType',
+                                              'registrationType',
+                                              'hostContainer',
+                                              'fcHostInitiators',
+                                              'iscsiHostInitiators',
+                                              'hostIPPorts',
+                                              'storageResources',
+                                              'hostLUNs',
+                                              'datastores',
+                                              'nfsShareAccesses',
+                                              'hostVVolDatastore',
+                                              'vms',
+                                              ])
+
+
+UnityhostContainer = namedtuple_defaults('UnityhostContainer', [
+                                                                'id',
+                                                                'lastPollTime',
+                                                                'port',
+                                                                'name',
+                                                                'type',
+                                                                'address',
+                                                                'description',
+                                                                'productName',
+                                                                'productVersion',
+                                                                'health',
+                                                                'hosts',
+                                                                ])
+
+
+UnityhostInitiator = namedtuple_defaults('UnityhostInitiator', [
+                                                                'id',
+                                                                'health',
+                                                                'type',
+                                                                'initiatorId',
+                                                                'parentHost',
+                                                                'isIgnored',
+                                                                'nodeWWN',
+                                                                'portWWN',
+                                                                'chapUserName',
+                                                                'isChapSecretEnabled',
+                                                                'paths',
+                                                                'iscsiType',
+                                                                'isBound',
+                                                                'sourceType',
+                                                                ])
+
+
+UnityhostInitiatorPath = namedtuple_defaults('UnityhostInitiatorPath', [
+                                                                        'id',
+                                                                        'registrationType',
+                                                                        'isLoggedIn',
+                                                                        'hostPushName',
+                                                                        'sessionIds',
+                                                                        'initiator',
+                                                                        'fcPort',
+                                                                        'iscsiPortal',
+                                                                        ])
+
+
+UnityhostIPPort = namedtuple_defaults('UnityhostIPPort', [
+                                                          'id',
+                                                          'name',
+                                                          'type',
+                                                          'address',
+                                                          'netmask',
+                                                          'v6PrefixLength',
+                                                          'isIgnored',
+                                                          'host',
+                                                          ])
+
+
+UnityhostLUN = namedtuple_defaults('UnityhostLUN', [
+                                                    'id',
+                                                    'host',
+                                                    'type',
+                                                    'hlu',
+                                                    'lun',
+                                                    'snap',
+                                                    'isReadOnly',
+                                                    ])
+
+
+UnityhostVVolDatastore = namedtuple_defaults('UnityhostVVolDatastore', [
+                                                                        'id',
+                                                                        'storageResource',
+                                                                        'host',
+                                                                        ])
+
+
+UnityinstalledSoftwareVersion = namedtuple_defaults('UnityinstalledSoftwareVersion', [
+                                                                                      'id',
+                                                                                      'version',
+                                                                                      'revision',
+                                                                                      'releaseDate',
+                                                                                      'languages',
+                                                                                      'hotFixes',
+                                                                                      'packageVersions',
+                                                                                      ])
+
+
+UnityioLimitParameters = namedtuple_defaults('UnityioLimitParameters', [
+                                                                        'ioLimitPolicy',
+                                                                        ])
+
+
+UnityioLimitPolicy = namedtuple_defaults('UnityioLimitPolicy', [
+                                                                'id',
+                                                                'name',
+                                                                'description',
+                                                                'isShared',
+                                                                'ioLimitRules',
+                                                                'luns',
+                                                                'snaps',
+                                                                ])
+
+
+UnityioLimitRule = namedtuple_defaults('UnityioLimitRule', [
+                                                            'id',
+                                                            'name',
+                                                            'description',
+                                                            'maxIOPS',
+                                                            'maxKBPS',
+                                                            'ioLimitpolicy',
+                                                            ])
+
+
+UnityioLimitSetting = namedtuple_defaults('UnityioLimitSetting', [
+                                                                  'id',
+                                                                  'isPaused',
+                                                                  ])
+
+
+UnityioModule = namedtuple_defaults('UnityioModule', [
+                                                      'id',
+                                                      'health',
+                                                      'needsReplacement',
+                                                      'parent',
+                                                      'slotNumber',
+                                                      'name',
+                                                      'manufacturer',
+                                                      'model',
+                                                      'emcPartNumber',
+                                                      'emcSerialNumber',
+                                                      'vendorPartNumber',
+                                                      'vendorSerialNumber',
+                                                      'systemName',
+                                                      'parentStorageProcessor',
+                                                      ])
+
+
+UnityipInterface = namedtuple_defaults('UnityipInterface', [
+                                                            'id',
+                                                            'ipPort',
+                                                            'ipProtocolVersion',
+                                                            'ipAddress',
+                                                            'netmask',
+                                                            'v6PrefixLength',
+                                                            'gateway',
+                                                            'vlanId',
+                                                            'type',
+                                                            ])
+
+
+UnityipPort = namedtuple_defaults('UnityipPort', [
+                                                  'id',
+                                                  'name',
+                                                  'shortName',
+                                                  'macAddress',
+                                                  'isLinkUp',
+                                                  'storageProcessor',
+                                                  ])
+
+
+UnityiscsiNode = namedtuple_defaults('UnityiscsiNode', [
+                                                        'id',
+                                                        'name',
+                                                        'ethernetPort',
+                                                        'alias',
+                                                        ])
+
+
+UnityiscsiPortal = namedtuple_defaults('UnityiscsiPortal', [
+                                                            'id',
+                                                            'ethernetPort',
+                                                            'iscsiNode',
+                                                            'ipAddress',
+                                                            'netmask',
+                                                            'v6PrefixLength',
+                                                            'gateway',
+                                                            'vlanId',
+                                                            'ipProtocolVersion',
+                                                            ])
+
+
+UnityiscsiSettings = namedtuple_defaults('UnityiscsiSettings', [
+                                                                'id',
+                                                                'isForwardCHAPRequired',
+                                                                'reverseCHAPUserName',
+                                                                'forwardGlobalCHAPUserName',
+                                                                'iSNSServer',
+                                                                ])
+
+
+Unityjob = namedtuple_defaults('Unityjob', [
+                                            'id',
+                                            'description',
+                                            'state',
+                                            'stateChangeTime',
+                                            'submitTime',
+                                            'startTime',
+                                            'endTime',
+                                            'elapsedTime',
+                                            'estRemainTime',
+                                            'progressPct',
+                                            'tasks',
+                                            'parametersOut',
+                                            'messageOut',
+                                            'isJobCancelable',
+                                            'isJobCancelled',
+                                            'clientData',
+                                            ])
+
+
+Unitylcc = namedtuple_defaults('Unitylcc', [
+                                            'id',
+                                            'health',
+                                            'needsReplacement',
+                                            'parent',
+                                            'slotNumber',
+                                            'name',
+                                            'manufacturer',
+                                            'model',
+                                            'sasExpanderVersions',
+                                            'emcPartNumber',
+                                            'emcSerialNumber',
+                                            'vendorPartNumber',
+                                            'vendorSerialNumber',
+                                            'currentSpeed',
+                                            'maxSpeed',
+                                            'parentDae',
+                                            ])
+
+
+UnityldapServer = namedtuple_defaults('UnityldapServer', [
+                                                          'id',
+                                                          'authority',
+                                                          'serverAddress',
+                                                          'bindDN',
+                                                          'protocol',
+                                                          'userSearchPath',
+                                                          'groupSearchPath',
+                                                          'userIdAttribute',
+                                                          'groupNameAttribute',
+                                                          'userObjectClass',
+                                                          'groupObjectClass',
+                                                          'groupMemberAttribute',
+                                                          'timeout',
+                                                          ])
+
+
+Unitylicense = namedtuple_defaults('Unitylicense', [
+                                                    'id',
+                                                    'name',
+                                                    'isInstalled',
+                                                    'version',
+                                                    'isValid',
+                                                    'issued',
+                                                    'expires',
+                                                    'isPermanent',
+                                                    'feature',
+                                                    ])
+
+
+UnitylinkAggregation = namedtuple_defaults('UnitylinkAggregation', [
+                                                                    'id',
+                                                                    'name',
+                                                                    'shortName',
+                                                                    'masterPort',
+                                                                    'ports',
+                                                                    'mtuSize',
+                                                                    'supportedMtus',
+                                                                    'macAddress',
+                                                                    'isLinkUp',
+                                                                    'parent',
+                                                                    'parentStorageProcessor',
+                                                                    ])
+
+
+UnitylocalizedMessage = namedtuple_defaults('UnitylocalizedMessage', [
+                                                                      'locale',
+                                                                      'message',
+                                                                      ])
+
+
+UnityloginSessionInfo = namedtuple_defaults('UnityloginSessionInfo', [
+                                                                      'id',
+                                                                      'user',
+                                                                      'roles',
+                                                                      'idleTimeout',
+                                                                      'isPasswordChangeRequired',
+                                                                      ])
+
+
+Unitylun = namedtuple_defaults('Unitylun', [
+                                            'id',
+                                            'health',
+                                            'name',
+                                            'description',
+                                            'type',
+                                            'sizeTotal',
+                                            'sizeUsed',
+                                            'sizeAllocated',
+                                            'perTierSizeUsed',
+                                            'isThinEnabled',
+                                            'storageResource',
+                                            'pool',
+                                            'wwn',
+                                            'tieringPolicy',
+                                            'defaultNode',
+                                            'isReplicationDestination',
+                                            'currentNode',
+                                            'snapSchedule',
+                                            'isSnapSchedulePaused',
+                                            'ioLimitPolicy',
+                                            'metadataSize',
+                                            'metadataSizeAllocated',
+                                            'snapWwn',
+                                            'snapsSize',
+                                            'snapsSizeAllocated',
+                                            'hostAccess',
+                                            'snapCount',
+                                            ])
+
+
+UnitylunMemberReplication = namedtuple_defaults('UnitylunMemberReplication', [
+                                                                              'srcStatus',
+                                                                              'networkStatus',
+                                                                              'dstStatus',
+                                                                              'srcLunId',
+                                                                              'dstLunId',
+                                                                              ])
+
+
+UnitymemoryModule = namedtuple_defaults('UnitymemoryModule', [
+                                                              'id',
+                                                              'health',
+                                                              'needsReplacement',
+                                                              'parent',
+                                                              'slotNumber',
+                                                              'name',
+                                                              'manufacturer',
+                                                              'model',
+                                                              'firmwareVersion',
+                                                              'size',
+                                                              'emcPartNumber',
+                                                              'emcSerialNumber',
+                                                              'vendorPartNumber',
+                                                              'vendorSerialNumber',
+                                                              'parentStorageProcessor',
+                                                              'isInserted',
+                                                              ])
+
+
+Unitymessage = namedtuple_defaults('Unitymessage', [
+                                                    'severity',
+                                                    'errorCode',
+                                                    'created',
+                                                    'httpStatusCode',
+                                                    'messages',
+                                                    ])
+
+
+Unitymetric = namedtuple_defaults('Unitymetric', [
+                                                  'id',
+                                                  'name',
+                                                  'path',
+                                                  'type',
+                                                  'description',
+                                                  'isHistoricalAvailable',
+                                                  'isRealtimeAvailable',
+                                                  'unitDisplayString',
+                                                  ])
+
+
+UnitymetricCollection = namedtuple_defaults('UnitymetricCollection', [
+                                                                      'id',
+                                                                      'interval',
+                                                                      'oldest',
+                                                                      'retention',
+                                                                      ])
+
+
+UnitymetricQueryResult = namedtuple_defaults('UnitymetricQueryResult', [
+                                                                        'queryId',
+                                                                        'path',
+                                                                        'timestamp',
+                                                                        'values',
+                                                                        ])
+
+
+UnitymetricRealTimeQuery = namedtuple_defaults('UnitymetricRealTimeQuery', [
+                                                                            'id',
+                                                                            'paths',
+                                                                            'interval',
+                                                                            'expiration',
+                                                                            ])
+
+
+UnitymetricService = namedtuple_defaults('UnitymetricService', [
+                                                                'id',
+                                                                'isHistoricalEnabled',
+                                                                ])
+
+
+UnitymetricValue = namedtuple_defaults('UnitymetricValue', [
+                                                            'path',
+                                                            'timestamp',
+                                                            'interval',
+                                                            'values',
+                                                            ])
+
+
+UnitymgmtInterface = namedtuple_defaults('UnitymgmtInterface', [
+                                                                'id',
+                                                                'configMode',
+                                                                'ethernetPort',
+                                                                'protocolVersion',
+                                                                'ipAddress',
+                                                                'netmask',
+                                                                'v6PrefixLength',
+                                                                'gateway',
+                                                                ])
+
+
+UnitymgmtInterfaceSettings = namedtuple_defaults('UnitymgmtInterfaceSettings', [
+                                                                                'id',
+                                                                                'v4ConfigMode',
+                                                                                'v6ConfigMode',
+                                                                                ])
+
+
+UnitynasServer = namedtuple_defaults('UnitynasServer', [
+                                                        'id',
+                                                        'name',
+                                                        'health',
+                                                        'homeSP',
+                                                        'currentSP',
+                                                        'pool',
+                                                        'sizeAllocated',
+                                                        'isReplicationEnabled',
+                                                        'isReplicationDestination',
+                                                        'replicationType',
+                                                        'defaultUnixUser',
+                                                        'defaultWindowsUser',
+                                                        'currentUnixDirectoryService',
+                                                        'isMultiProtocolEnabled',
+                                                        'isWindowsToUnixUsernameMappingEnabled',
+                                                        'allowUnmappedUser',
+                                                        'cifsServer',
+                                                        'preferredInterfaceSettings',
+                                                        'fileDNSServer',
+                                                        'fileInterface',
+                                                        'virusChecker',
+                                                        ])
+
+
+UnitynfsServer = namedtuple_defaults('UnitynfsServer', [
+                                                        'id',
+                                                        'hostName',
+                                                        'nasServer',
+                                                        'fileInterfaces',
+                                                        'nfsv4Enabled',
+                                                        'isSecureEnabled',
+                                                        'kdcType',
+                                                        'servicePrincipalName',
+                                                        'isExtendedCredentialsEnabled',
+                                                        'credentialsCacheTTL',
+                                                        ])
+
+
+UnitynfsShare = namedtuple_defaults('UnitynfsShare', [
+                                                      'id',
+                                                      'type',
+                                                      'role',
+                                                      'filesystem',
+                                                      'snap',
+                                                      'name',
+                                                      'path',
+                                                      'exportPaths',
+                                                      'description',
+                                                      'isReadOnly',
+                                                      'creationTime',
+                                                      'modificationTime',
+                                                      'defaultAccess',
+                                                      'minSecurity',
+                                                      'noAccessHosts',
+                                                      'readOnlyHosts',
+                                                      'readWriteHosts',
+                                                      'rootAccessHosts',
+                                                      'hostAccesses',
+                                                      ])
+
+
+UnityntpServer = namedtuple_defaults('UnityntpServer', [
+                                                        'id',
+                                                        'addresses',
+                                                        ])
+
+
+Unitypool = namedtuple_defaults('Unitypool', [
+                                              'id',
+                                              'health',
+                                              'name',
+                                              'description',
+                                              'storageResourceType',
+                                              'raidType',
+                                              'sizeFree',
+                                              'sizeTotal',
+                                              'sizeUsed',
+                                              'sizeSubscribed',
+                                              'alertThreshold',
+                                              'isFASTCacheEnabled',
+                                              'tiers',
+                                              'creationTime',
+                                              'isEmpty',
+                                              'poolFastVP',
+                                              'isHarvestEnabled',
+                                              'harvestState',
+                                              'isSnapHarvestEnabled',
+                                              'poolSpaceHarvestHighThreshold',
+                                              'poolSpaceHarvestLowThreshold',
+                                              'snapSpaceHarvestHighThreshold',
+                                              'snapSpaceHarvestLowThreshold',
+                                              'metadataSizeSubscribed',
+                                              'snapSizeSubscribed',
+                                              'metadataSizeUsed',
+                                              'snapSizeUsed',
+                                              'rebalanceProgress',
+                                              ])
+
+
+UnitypoolConsumer = namedtuple_defaults('UnitypoolConsumer', [
+                                                              'id',
+                                                              ])
+
+
+UnitypoolConsumerAllocation = namedtuple_defaults('UnitypoolConsumerAllocation', [
+                                                                                  'id',
+                                                                                  'pool',
+                                                                                  'consumer',
+                                                                                  'consumerType',
+                                                                                  'sizeAllocatedTotal',
+                                                                                  'snapsSizeAllocated',
+                                                                                  ])
+
+
+UnitypoolUnit = namedtuple_defaults('UnitypoolUnit', [
+                                                      'id',
+                                                      'type',
+                                                      'health',
+                                                      'name',
+                                                      'description',
+                                                      'wwn',
+                                                      'sizeTotal',
+                                                      'tierType',
+                                                      'pool',
+                                                      ])
+
+
+UnitypowerSupply = namedtuple_defaults('UnitypowerSupply', [
+                                                            'id',
+                                                            'health',
+                                                            'needsReplacement',
+                                                            'parent',
+                                                            'slotNumber',
+                                                            'name',
+                                                            'manufacturer',
+                                                            'model',
+                                                            'firmwareVersion',
+                                                            'emcSerialNumber',
+                                                            'vendorPartNumber',
+                                                            'vendorSerialNumber',
+                                                            'emcPartNumber',
+                                                            'parentDae',
+                                                            'parentDpe',
+                                                            ])
+
+
+UnitypreferredInterfaceSettings = namedtuple_defaults('UnitypreferredInterfaceSettings', [
+                                                                                          'id',
+                                                                                          'nasServer',
+                                                                                          'productionIpV4',
+                                                                                          'productionIpV6',
+                                                                                          'backupIpV4',
+                                                                                          'backupIpV6',
+                                                                                          'sourceParameters',
+                                                                                          'replicationPolicy',
+                                                                                          ])
+
+
+UnityquotaConfig = namedtuple_defaults('UnityquotaConfig', [
+                                                            'id',
+                                                            'filesystem',
+                                                            'treeQuota',
+                                                            'quotaPolicy',
+                                                            'isUserQuotaEnabled',
+                                                            'isAccessDenyEnabled',
+                                                            'gracePeriod',
+                                                            'defaultHardLimit',
+                                                            'defaultSoftLimit',
+                                                            'lastUpdateTimeOfTreeQuotas',
+                                                            'lastUpdateTimeOfUserQuotas',
+                                                            ])
+
+
+UnityraidGroup = namedtuple_defaults('UnityraidGroup', [
+                                                        'id',
+                                                        'type',
+                                                        'health',
+                                                        'name',
+                                                        'description',
+                                                        'wwn',
+                                                        'sizeTotal',
+                                                        'tierType',
+                                                        'pool',
+                                                        'diskGroup',
+                                                        'raidType',
+                                                        'stripeWidth',
+                                                        'parityDisks',
+                                                        'disks',
+                                                        ])
+
+
+UnityremoteInterface = namedtuple_defaults('UnityremoteInterface', [
+                                                                    'id',
+                                                                    'remoteId',
+                                                                    'name',
+                                                                    'address',
+                                                                    'remoteSystem',
+                                                                    'node',
+                                                                    'capability',
+                                                                    ])
+
+
+UnityremoteSyslog = namedtuple_defaults('UnityremoteSyslog', [
+                                                              'id',
+                                                              'address',
+                                                              'protocol',
+                                                              'facility',
+                                                              'enabled',
+                                                              ])
+
+
+UnityremoteSystem = namedtuple_defaults('UnityremoteSystem', [
+                                                              'id',
+                                                              'name',
+                                                              'model',
+                                                              'serialNumber',
+                                                              'health',
+                                                              'managementAddress',
+                                                              'connectionType',
+                                                              'syncFcPorts',
+                                                              'username',
+                                                              'localSPAInterfaces',
+                                                              'localSPBInterfaces',
+                                                              'remoteSPAInterfaces',
+                                                              'remoteSPBInterfaces',
+                                                              ])
+
+
+UnityreplicationInterface = namedtuple_defaults('UnityreplicationInterface', [
+                                                                              'id',
+                                                                              'ipPort',
+                                                                              'health',
+                                                                              'ipAddress',
+                                                                              'ipProtocolVersion',
+                                                                              'netmask',
+                                                                              'v6PrefixLength',
+                                                                              'gateway',
+                                                                              'vlanId',
+                                                                              'macAddress',
+                                                                              'name',
+                                                                              ])
+
+
+UnityreplicationSession = namedtuple_defaults('UnityreplicationSession', [
+                                                                          'id',
+                                                                          'name',
+                                                                          'replicationResourceType',
+                                                                          'status',
+                                                                          'health',
+                                                                          'maxTimeOutOfSync',
+                                                                          'srcStatus',
+                                                                          'networkStatus',
+                                                                          'dstStatus',
+                                                                          'lastSyncTime',
+                                                                          'syncState',
+                                                                          'remoteSystem',
+                                                                          'localRole',
+                                                                          'srcResourceId',
+                                                                          'srcSPAInterface',
+                                                                          'srcSPBInterface',
+                                                                          'dstResourceId',
+                                                                          'dstSPAInterface',
+                                                                          'dstSPBInterface',
+                                                                          'members',
+                                                                          'syncProgress',
+                                                                          'currentTransferEstRemainTime',
+                                                                          ])
+
+
+UnityresourceRef = namedtuple_defaults('UnityresourceRef', [
+                                                            'resource',
+                                                            'id',
+                                                            ])
+
+
+Unityrole = namedtuple_defaults('Unityrole', [
+                                              'id',
+                                              'name',
+                                              'description',
+                                              ])
+
+
+UnityroleMapping = namedtuple_defaults('UnityroleMapping', [
+                                                            'id',
+                                                            'authorityName',
+                                                            'roleName',
+                                                            'entityName',
+                                                            'mappingType',
+                                                            ])
+
+
+Unityroute = namedtuple_defaults('Unityroute', [
+                                                'id',
+                                                'ipInterface',
+                                                'destination',
+                                                'netmask',
+                                                'v6PrefixLength',
+                                                'gateway',
+                                                ])
+
+
+UnityrpChapSettings = namedtuple_defaults('UnityrpChapSettings', [
+                                                                  'id',
+                                                                  'outgoingForwardChapUsername',
+                                                                  ])
+
+
+UnitysasPort = namedtuple_defaults('UnitysasPort', [
+                                                    'id',
+                                                    'health',
+                                                    'needsReplacement',
+                                                    'parent',
+                                                    'name',
+                                                    'port',
+                                                    'currentSpeed',
+                                                    'connectorType',
+                                                    'parentStorageProcessor',
+                                                    ])
+
+
+UnitysecuritySettings = namedtuple_defaults('UnitysecuritySettings', [
+                                                                      'id',
+                                                                      'isFIPSEnabled',
+                                                                      'isSSOEnabled',
+                                                                      'isTLS1Enabled',
+                                                                      ])
+
+
+UnityserviceAction = namedtuple_defaults('UnityserviceAction', [
+                                                                'id',
+                                                                'scope',
+                                                                'name',
+                                                                'description',
+                                                                'isApplicable',
+                                                                'applyCondition',
+                                                                ])
+
+
+UnityserviceContract = namedtuple_defaults('UnityserviceContract', [
+                                                                    'id',
+                                                                    'contractId',
+                                                                    'contractNumber',
+                                                                    'contractStatus',
+                                                                    'levelOfService',
+                                                                    'serviceLineId',
+                                                                    'lastUpdated',
+                                                                    'productStartDate',
+                                                                    'productEndDate',
+                                                                    ])
+
+
+UnityserviceInfo = namedtuple_defaults('UnityserviceInfo', [
+                                                            'id',
+                                                            'productName',
+                                                            'productSerialNumber',
+                                                            'systemUUID',
+                                                            'isSSHEnabled',
+                                                            'esrsStatus',
+                                                            'sps',
+                                                            ])
+
+
+UnitysmtpServer = namedtuple_defaults('UnitysmtpServer', [
+                                                          'id',
+                                                          'address',
+                                                          'type',
+                                                          ])
+
+
+Unitysnap = namedtuple_defaults('Unitysnap', [
+                                              'id',
+                                              'name',
+                                              'description',
+                                              'storageResource',
+                                              'lun',
+                                              'snapGroup',
+                                              'parentSnap',
+                                              'creationTime',
+                                              'expirationTime',
+                                              'creatorType',
+                                              'creatorUser',
+                                              'creatorSchedule',
+                                              'isSystemSnap',
+                                              'isModifiable',
+                                              'attachedWWN',
+                                              'accessType',
+                                              'isReadOnly',
+                                              'lastWritableTime',
+                                              'isModified',
+                                              'isAutoDelete',
+                                              'state',
+                                              'size',
+                                              'ioLimitPolicy',
+                                              ])
+
+
+UnitysnapSchedule = namedtuple_defaults('UnitysnapSchedule', [
+                                                              'id',
+                                                              'name',
+                                                              'isDefault',
+                                                              'isModified',
+                                                              'version',
+                                                              'rules',
+                                                              'storageResources',
+                                                              ])
+
+
+UnitysoftwareUpgradeSession = namedtuple_defaults('UnitysoftwareUpgradeSession', [
+                                                                                  'id',
+                                                                                  'type',
+                                                                                  'candidate',
+                                                                                  'caption',
+                                                                                  'status',
+                                                                                  'messages',
+                                                                                  'creationTime',
+                                                                                  'elapsedTime',
+                                                                                  'percentComplete',
+                                                                                  'tasks',
+                                                                                  ])
+
+
+Unityssc = namedtuple_defaults('Unityssc', [
+                                            'id',
+                                            'health',
+                                            'needsReplacement',
+                                            'parent',
+                                            'slotNumber',
+                                            'name',
+                                            'parentDae',
+                                            ])
+
+
+Unityssd = namedtuple_defaults('Unityssd', [
+                                            'id',
+                                            'health',
+                                            'needsReplacement',
+                                            'parent',
+                                            'slotNumber',
+                                            'name',
+                                            'manufacturer',
+                                            'model',
+                                            'firmwareVersion',
+                                            'emcPartNumber',
+                                            'emcSerialNumber',
+                                            'vendorPartNumber',
+                                            'vendorSerialNumber',
+                                            'parentStorageProcessor',
+                                            ])
+
+
+UnitystorageProcessor = namedtuple_defaults('UnitystorageProcessor', [
+                                                                      'id',
+                                                                      'parent',
+                                                                      'health',
+                                                                      'needsReplacement',
+                                                                      'isRescueMode',
+                                                                      'model',
+                                                                      'slotNumber',
+                                                                      'name',
+                                                                      'emcPartNumber',
+                                                                      'emcSerialNumber',
+                                                                      'manufacturer',
+                                                                      'vendorPartNumber',
+                                                                      'vendorSerialNumber',
+                                                                      'sasExpanderVersion',
+                                                                      'biosFirmwareRevision',
+                                                                      'postFirmwareRevision',
+                                                                      'memorySize',
+                                                                      'parentDpe',
+                                                                      ])
+
+
+UnitystorageResource = namedtuple_defaults('UnitystorageResource', [
+                                                                    'id',
+                                                                    'health',
+                                                                    'name',
+                                                                    'description',
+                                                                    'type',
+                                                                    'isReplicationDestination',
+                                                                    'replicationType',
+                                                                    'sizeTotal',
+                                                                    'sizeUsed',
+                                                                    'sizeAllocated',
+                                                                    'thinStatus',
+                                                                    'esxFilesystemMajorVersion',
+                                                                    'esxFilesystemBlockSize',
+                                                                    'snapSchedule',
+                                                                    'isSnapSchedulePaused',
+                                                                    'relocationPolicy',
+                                                                    'perTierSizeUsed',
+                                                                    'blockHostAccess',
+                                                                    'metadataSize',
+                                                                    'metadataSizeAllocated',
+                                                                    'snapsSizeTotal',
+                                                                    'snapsSizeAllocated',
+                                                                    'snapCount',
+                                                                    'vmwareUUID',
+                                                                    'pools',
+                                                                    'datastores',
+                                                                    'filesystem',
+                                                                    'hostVVolDatastore',
+                                                                    'luns',
+                                                                    'virtualVolumes',
+                                                                    ])
+
+
+UnitystorageResourceCapabilityProfile = namedtuple_defaults('UnitystorageResourceCapabilityProfile', [
+                                                                                                      'id',
+                                                                                                      'storageResource',
+                                                                                                      'capabilityProfile',
+                                                                                                      'isInUse',
+                                                                                                      'sizeUsed',
+                                                                                                      'sizeAllocated',
+                                                                                                      'sizeTotal',
+                                                                                                      'logicalSizeUsed',
+                                                                                                      ])
+
+
+UnitystorageTier = namedtuple_defaults('UnitystorageTier', [
+                                                            'id',
+                                                            'tierType',
+                                                            'raidConfigurations',
+                                                            'disksTotal',
+                                                            'disksUnused',
+                                                            'virtualDisksTotal',
+                                                            'virtualDisksUnused',
+                                                            'sizeTotal',
+                                                            'sizeFree',
+                                                            ])
+
+
+UnitystorageTierConfiguration = namedtuple_defaults('UnitystorageTierConfiguration', [
+                                                                                      'storageTier',
+                                                                                      'raidType',
+                                                                                      'stripeWidth',
+                                                                                      'disksTotal',
+                                                                                      'sizeTotal',
+                                                                                      'diskGroupConfigurations',
+                                                                                      ])
+
+
+UnitysupportAsset = namedtuple_defaults('UnitysupportAsset', [
+                                                              'id',
+                                                              'name',
+                                                              'description',
+                                                              ])
+
+
+UnitysupportService = namedtuple_defaults('UnitysupportService', [
+                                                                  'id',
+                                                                  'supportUsername',
+                                                                  'supportCredentialStatus',
+                                                                  'isEMCServiced',
+                                                                  'isContractReportEnabled',
+                                                                  ])
+
+
+Unitysystem = namedtuple_defaults('Unitysystem', [
+                                                  'id',
+                                                  'health',
+                                                  'name',
+                                                  'model',
+                                                  'serialNumber',
+                                                  'internalModel',
+                                                  'platform',
+                                                  'macAddress',
+                                                  'isEULAAccepted',
+                                                  'isUpgradeComplete',
+                                                  'isAutoFailbackEnabled',
+                                                  'currentPower',
+                                                  'avgPower',
+                                                  ])
+
+
+UnitysystemInformation = namedtuple_defaults('UnitysystemInformation', [
+                                                                        'id',
+                                                                        'contactFirstName',
+                                                                        'contactLastName',
+                                                                        'contactCompany',
+                                                                        'contactPhone',
+                                                                        'contactEmail',
+                                                                        'locationName',
+                                                                        'streetAddress',
+                                                                        'city',
+                                                                        'state',
+                                                                        'zipcode',
+                                                                        'country',
+                                                                        'siteId',
+                                                                        'contactMobilePhone',
+                                                                        ])
+
+
+UnitysystemLimit = namedtuple_defaults('UnitysystemLimit', [
+                                                            'id',
+                                                            'name',
+                                                            'description',
+                                                            'unit',
+                                                            'limitValue',
+                                                            'thresholdValue',
+                                                            'resources',
+                                                            'license',
+                                                            ])
+
+
+UnitysystemTime = namedtuple_defaults('UnitysystemTime', [
+                                                          'id',
+                                                          'time',
+                                                          ])
+
+
+UnitytechnicalAdvisory = namedtuple_defaults('UnitytechnicalAdvisory', [
+                                                                        'id',
+                                                                        'knowledgeBaseId',
+                                                                        'description',
+                                                                        'modificationTime',
+                                                                        ])
+
+
+UnitytreeQuota = namedtuple_defaults('UnitytreeQuota', [
+                                                        'id',
+                                                        'filesystem',
+                                                        'quotaConfig',
+                                                        'path',
+                                                        'description',
+                                                        'state',
+                                                        'hardLimit',
+                                                        'softLimit',
+                                                        'remainingGracePeriod',
+                                                        'sizeUsed',
+                                                        ])
+
+
+UnityuncommittedPort = namedtuple_defaults('UnityuncommittedPort', [
+                                                                    'id',
+                                                                    'health',
+                                                                    'name',
+                                                                    'portNumber',
+                                                                    'connectorType',
+                                                                    'sfpSupportedSpeeds',
+                                                                    'sfpSupportedProtocols',
+                                                                    'needsReplacement',
+                                                                    'storageProcessor',
+                                                                    'parentIOModule',
+                                                                    'parentStorageProcessor',
+                                                                    'parent',
+                                                                    ])
+
+
+UnityurServer = namedtuple_defaults('UnityurServer', [
+                                                      'address',
+                                                      'id',
+                                                      ])
+
+
+Unityuser = namedtuple_defaults('Unityuser', [
+                                              'id',
+                                              'name',
+                                              'role',
+                                              ])
+
+
+UnityuserQuota = namedtuple_defaults('UnityuserQuota', [
+                                                        'id',
+                                                        'filesystem',
+                                                        'treeQuota',
+                                                        'uid',
+                                                        'state',
+                                                        'hardLimit',
+                                                        'softLimit',
+                                                        'remainingGracePeriod',
+                                                        'sizeUsed',
+                                                        ])
+
+
+UnityvirtualVolume = namedtuple_defaults('UnityvirtualVolume', [
+                                                                'id',
+                                                                'health',
+                                                                'name',
+                                                                'vvolType',
+                                                                'replicaType',
+                                                                'parent',
+                                                                'storageResource',
+                                                                'pool',
+                                                                'capabilityProfile',
+                                                                'policyProfileName',
+                                                                'isCompliant',
+                                                                'isThinEnabled',
+                                                                'sizeTotal',
+                                                                'sizeUsed',
+                                                                'bindings',
+                                                                'vmUUID',
+                                                                'vm',
+                                                                'vmDisk',
+                                                                ])
+
+
+UnityvirusChecker = namedtuple_defaults('UnityvirusChecker', [
+                                                              'id',
+                                                              'nasServer',
+                                                              'isEnabled',
+                                                              ])
+
+
+Unityvm = namedtuple_defaults('Unityvm', [
+                                          'id',
+                                          'datastore',
+                                          'name',
+                                          'guestAddresses',
+                                          'guestHostName',
+                                          'notes',
+                                          'osType',
+                                          'host',
+                                          'state',
+                                          'vmDisks',
+                                          'virtualVolumes',
+                                          ])
+
+
+UnityvmDisk = namedtuple_defaults('UnityvmDisk', [
+                                                  'datastore',
+                                                  'id',
+                                                  'vm',
+                                                  'name',
+                                                  'spaceTotal',
+                                                  'type',
+                                                  'virtualVolumes',
+                                                  ])
+
+
+UnityvmwareNasPEServer = namedtuple_defaults('UnityvmwareNasPEServer', [
+                                                                        'id',
+                                                                        'nasServer',
+                                                                        'fileInterfaces',
+                                                                        'boundVVolCount',
+                                                                        ])
+
+
+UnityvmwarePE = namedtuple_defaults('UnityvmwarePE', [
+                                                      'id',
+                                                      'vmwareNasPEServer',
+                                                      'name',
+                                                      'type',
+                                                      'vmwareUUID',
+                                                      'exportPath',
+                                                      'ipAddress',
+                                                      'defaultNode',
+                                                      'currentNode',
+                                                      'wwn',
+                                                      'naa',
+                                                      'vvolds',
+                                                      'host',
+                                                      'boundVVolCount',
+                                                      'health',
+                                                      ])
+
+
+Unityx509Certificate = namedtuple_defaults('Unityx509Certificate', [
+                                                                    'id',
+                                                                    'type',
+                                                                    'service',
+                                                                    'scope',
+                                                                    'isTrustAnchor',
+                                                                    'version',
+                                                                    'serialNumber',
+                                                                    'signatureAlgorithm',
+                                                                    'issuer',
+                                                                    'validFrom',
+                                                                    'validTo',
+                                                                    'subject',
+                                                                    'subjectAlternativeName',
+                                                                    'publicKeyAlgorithm',
+                                                                    'keyLength',
+                                                                    'thumbprintAlgorithm',
+                                                                    'thumbprint',
+                                                                    'hasPrivateKey',
+                                                                    ])
+
+
diff --git a/EMCUnity/__init__.py b/EMCUnity/__init__.py
new file mode 100755
index 0000000000000000000000000000000000000000..23b482c06635f3449910375622d0b1b7312a897d_RU1DVW5pdHkvX19pbml0X18ucHk=
--- /dev/null
+++ b/EMCUnity/__init__.py
@@ -0,0 +1,2 @@
+from .Unity import *
+from .UnityClasses import *
diff --git a/EMCUnity/scripts/extract_obj_from_docs.py b/EMCUnity/scripts/extract_obj_from_docs.py
new file mode 100755
index 0000000000000000000000000000000000000000..23b482c06635f3449910375622d0b1b7312a897d_RU1DVW5pdHkvc2NyaXB0cy9leHRyYWN0X29ial9mcm9tX2RvY3MucHk=
--- /dev/null
+++ b/EMCUnity/scripts/extract_obj_from_docs.py
@@ -0,0 +1,28 @@
+from BeautifulSoup import BeautifulSoup
+import glob
+
+object_files = glob.glob("*.html")
+
+for file in object_files:
+    soup = BeautifulSoup(open(file))
+
+    obj_properties = []
+
+    attr_table = soup.table
+    if attr_table:
+        for row in attr_table.findAll('tr'):
+            prop = row.td.text
+            if prop == 'Attribute':
+                continue 
+            obj_properties.append(prop)
+
+    obj_name = file[:-5]
+    line1 = "Unity%s = namedtuple_defaults('Unity%s', [" % (obj_name, obj_name)
+    print(line1)
+    for i in obj_properties:
+        print(" " * len(line1) + "'%s'," % i)
+    print(" " * len(line1) + "])\n\n")
+    
+
+        
+
diff --git a/LICENSE b/LICENSE
new file mode 100755
index 0000000000000000000000000000000000000000..23b482c06635f3449910375622d0b1b7312a897d_TElDRU5TRQ==
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 EMC Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
\ No newline at end of file
diff --git a/README.md b/README.md
new file mode 100755
index 0000000000000000000000000000000000000000..23b482c06635f3449910375622d0b1b7312a897d_UkVBRE1FLm1k
--- /dev/null
+++ b/README.md
@@ -0,0 +1,94 @@
+EMCUnity
+=======================
+
+EMCUnity provides a Python interface to the Dell EMC Unity RESTful API
+
+## Description
+
+This module has been developed to provide a pythonic interface for interacting with Dell EMC's Unity line of mid-range storage arrays.  This module supports both Physical arrays (such as the 300/400/500/600 hybrid and all flash models) along with the UnityVSA.  
+
+Although this module provides a layer of abstraction between the REST API and the developer, it is recommended that you review the following documents as a reference, particularly when referencing object names, fields that are available, and the use of filters when querying the array.
+
+[Dell EMC Unity Unisphere Management REST API Reference Guide](https://dl.dell.com/content/manual24434307-dell-emc-unity-unisphere-management-rest-api-reference-guide-pdf.pdf?language=en-us)
+
+[Dell EMC Unity Family Unisphere Management REST API Programmer's Guide](https://dl.dell.com/content/docu69331-dell-emc-unity-family-unisphere-management-rest-api-programmer's-guide.pdf?language=en-us)
+
+As of today the module is fully functional for retrieving information from the array along with performing manual POST and DELETE requests.   Work is continuing to create helper functions to simplify common tasks.
+
+## Installation
+
+*Prerequisites*
+
+1.  Python 2.7 (Python 3 support is coming)
+2.  Requests module
+
+## Sample usage
+
+Creating a LUN
+
+    # Connect to the array
+    unity = Unity('unity.ktelep.local','admin','TooManySecrets')
+
+    # Gather a list of pools, we need the pool ID for LUN creation
+    pools = unity.pool()
+    first_pool = pools[0].id
+
+    # Create a lun with a new Unitylun object
+    new_lun = Unitylun(name="TestLUN",pool=first_pool,sizeTotal=50000000,
+                 description="Test Description")
+
+    # Pass it to create_lun
+    response = unity.create_lun_from_obj(new_lun)
+    print response
+
+    # Create a new lun with parameters
+    response = unity.create_lun("TestLUN2", first_pool, 50000000, "Test Desc")
+    print response
+
+
+Any object defined in the API Reference Guide is accessible as a function, for example gathering license keys shown below.  This pattern is available for any referenced object.
+
+
+    # Connect to the array
+    unity = Unity('unity.ktelep.local','admin','TooManySecrets')
+
+    unity.license()   # Returns all licenses as Unitylicense objects
+    unity.license(item_id='QUALITY_OF_SERVICE')  # Returns the QOS License
+    unity.license(item_filter='id LK "UNISPHERE%"') # Returns Licenses starting with "UNISPHERE"
+    unity.license(item_name='FAST_VP') # Returns license named FAST_VP
+
+
+You can also make direct calls (GET,POST,DELETE) to the REST API
+
+    # Request for DAE instances, returns response object  
+    response = unity.get('/types/dae/instances')
+    json_data = response.json()
+
+    # Create a LUN manually (Size is in bytes)
+    payload = {'name': "NewLUN"
+               'lunParameters':{'pool':{'id':'pool_1'},
+                                        'size': 50000000}}
+
+    response = self.post('/types/storageResource/action/createLun',payload)
+
+    new_id = response.json()['content']['storageResource']['id']
+
+    # Delete a LUN manually
+    response = self.delete('/instances/storageResource/%s' % new_id)  
+
+
+Licensing
+---------
+This software is provided under the MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+Status API Training Shop Blog About Pricing
+
+
+Support
+-------
+Please file bugs and issues at the Github issues page.