pyPreservica 2.8.0__tar.gz → 2.8.2__tar.gz

{pypreservica-2.8.0 → pypreservica-2.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyPreservica
-Version: 2.8.0
+Version: 2.8.2
 Summary: Python library for the Preservica API
 Home-page: https://pypreservica.readthedocs.io/
 Author: James Carr

{pypreservica-2.8.0 → pypreservica-2.8.2}/pyPreservica/__init__.py

@@ -18,11 +18,11 @@ from .adminAPI import AdminAPI
 from .monitorAPI import MonitorAPI, MonitorCategory, MonitorStatus, MessageStatus
 from .webHooksAPI import WebHooksAPI, TriggerType, WebHookHandler
 from .authorityAPI import AuthorityAPI, Table
-from .mdformsAPI import MetadataGroupsAPI, GroupFieldType, GroupField, Group
+from .mdformsAPI import MetadataGroupsAPI, Group, GroupField, GroupFieldType
 
 __author__ = "James Carr (drjamescarr@gmail.com)"
 
 # Version of the pyPreservica package
-__version__ = "2.8.0"
+__version__ = "2.8.2"
 
 __license__ = "Apache License Version 2.0"

{pypreservica-2.8.0 → pypreservica-2.8.2}/pyPreservica/mdformsAPI.py

@@ -8,9 +8,8 @@ author:     James Carr
 licence:    Apache License 2.0
 
 """
-import json
 import xml.etree.ElementTree
-from typing import Callable, List
+from typing import Callable, List, Union, Generator
 
 from pyPreservica.common import *
 
@@ -60,13 +59,77 @@ class Group:
     name: str
     description: str
     schemaUri: str
-    fields: List[GroupField] = []
+    fields: List[GroupField]
+
+    def __init__(self, name: str, description: str):
+        self.name = name
+        self.description = description
+        self.fields = []
 
     def __str__(self):
         return (f"Group ID: {self.group_id}\n" + f"Group Name: {self.name}\n" +
                 f"Group Description: {self.description}\n" + f"Group Schema URI: {self.schemaUri}")
 
 
+def _object_from_json_(json_doc: dict) -> Group:
+    """
+    Create a JSON dict object from a Group object
+    """
+
+    group: Group = Group(name=json_doc['name'], description=json_doc['description'])
+    group.fields = []
+    if 'id' in json_doc:
+        group.group_id = json_doc['id']
+    if 'schemaUri' in json_doc:
+        group.schemaUri = json_doc['schemaUri']
+
+    if 'fields' in json_doc:
+        for field in json_doc['fields']:
+            gf: GroupField = GroupField(field['id'], field['name'], GroupFieldType(str(field['type'])))
+            if 'minOccurs' in field:
+                gf.minOccurs = int(field['minOccurs'])
+            if 'maxOccurs' in field:
+                gf.maxOccurs = int(field['maxOccurs'])
+            if 'visible' in field:
+                gf.visible = bool(field['visible'])
+            if 'editable' in field:
+                gf.editable = bool(field['editable'])
+            if 'values' in field:
+                for v in field['values']:
+                    gf.values.append(str(v))
+            if 'defaultValue' in field:
+                gf.default = str(field['defaultValue'])
+            if 'indexed' in field:
+                gf.indexed = bool(field['indexed'])
+
+            group.fields.append(gf)
+
+    return group
+
+
+def _json_from_object_(group: Group) -> dict:
+    """
+    Create a JSON dict object from a Group object
+    """
+
+    fields = []
+    for field in group.fields:
+        f = {"id": field.field_id, "name": field.name, "type": str(field.field_type.value)}
+        f["minOccurs"] = str(field.minOccurs)
+        f["maxOccurs"] = str(field.maxOccurs)
+        f["visible"] = str(field.visible)
+        f["editable"] = str(field.editable)
+        if (field.values is not None) and (len(field.values) > 0):
+            f["values"] = [item for item in field.values]
+        f["defaultValue"] = str(field.default)
+        f["indexed"] = str(field.indexed)
+        fields.append(f)
+
+    json_doc = {"name": group.name, "description": group.description, "fields": fields}
+
+    return json_doc
+
+
 class MetadataGroupsAPI(AuthenticatedAPI):
     def __init__(self, username: str = None, password: str = None, tenant: str = None, server: str = None,
                  use_shared_secret: bool = False, two_fa_secret_key: str = None,
@@ -100,7 +163,7 @@ class MetadataGroupsAPI(AuthenticatedAPI):
          :param group_id: Group ID
          :type group_id: str
 
-         :return: None
+         :return:
          :rtype: None
 
          """
@@ -118,7 +181,46 @@ class MetadataGroupsAPI(AuthenticatedAPI):
                 logger.error(exception)
                 raise exception
 
-    def add_group(self, group_name: str, group_description: str, fields: List[GroupField]):
+    def add_fields(self, group_id: str, new_fields: List[GroupField]) -> dict:
+        """
+        Add new metadata fields to an existing Group
+
+        The new fields are appended to the end of the group
+
+        :param group_id: The group ID of the group to update
+        :type group_id: str
+
+        :param new_fields: The list of new fields to add to the group
+        :type new_fields: List[GroupField]
+
+        :return:  The updated Metadata Group as a JSON dict
+        :rtype:   dict
+
+
+        """
+
+        this_group: Group = self.group(group_id)
+
+        for field in new_fields:
+            this_group.fields.append(field)
+
+        doc = _json_from_object_(this_group)
+
+        headers = {HEADER_TOKEN: self.token, 'Content-Type': 'application/json;charset=UTF-8'}
+        url = f'{self.protocol}://{self.server}/api/metadata/groups/{group_id}'
+        with self.session.put(url, headers=headers, json=doc) as request:
+            if request.status_code == requests.codes.unauthorized:
+                self.token = self.__token__()
+                return self.add_fields(group_id, new_fields)
+            elif request.status_code == requests.codes.created:
+                return json.loads(str(request.content.decode('utf-8')))
+            else:
+                exception = HTTPException(None, request.status_code, request.url, "add_fields",
+                                          request.content.decode('utf-8'))
+                logger.error(exception)
+                raise exception
+
+    def add_group(self, group_name: str, group_description: str, fields: List[GroupField]) -> dict:
         """
           Create a new Metadata Group GroupFields
 
@@ -131,79 +233,69 @@ class MetadataGroupsAPI(AuthenticatedAPI):
           :param fields: The list of fields
           :type fields: List[GroupField]
 
-          :return:  JSON document
-          :rtype: str
+          :return:  The new metadata Group as a JSON dict
+          :rtype:   dict
 
           """
 
-        fields_str_list = []
-        for field in fields:
-
-            values = ""
-            if (field.values is not None) and (len(field.values) > 0):
-                values = f"""\n"values" : [ {",".join('"' + item + '"' for item in field.values)} ],
-                """
-
-            fields_str = f"""{{
-            "id" : "{field.field_id}",
-            "name": "{field.name}",
-            "type": "{field.field_type.value}",
-            "minOccurs": "{field.minOccurs}",
-            "maxOccurs": "{field.maxOccurs}",
-            "visible": "{field.visible}", {values}
-            "editable": "{field.editable}",
-            "defaultValue": "{field.default}",
-            "indexed": "{field.indexed}"
-            }}"""
-            
-            fields_str_list.append(fields_str)
-
-        json_doc = f"""{{
-          "name" : "{group_name}",
-          "description" : "{group_description}",
-          "fields" : [ {",".join(fields_str_list)}  ]
-        }}"""
-
-        print(json_doc)
-
-        json_response = self.add_group_json(json_doc)
-        group_id = json_response['id']
-        return self.group(group_id)
-
-    def add_group_json(self, json_document: str) -> str:
+        group: Group = Group(group_name, group_description)
+        group.fields = fields
+
+        json_document: dict = _json_from_object_(group)
+        json_response: dict = self.add_group_json(json_document)
+        return json_response
+
+    def add_group_json(self, json_object: Union[dict, str]) -> dict:
         """
-         Create a new Metadata Group using a JSON document
+          Create a new Metadata Group using a JSON dictionary object or document
 
-         :param json_document: JSON document
-         :type json_document: str
+          :param json_object: JSON dictionary or string
+          :type json_object: dict
 
-         :return:  JSON document
-         :rtype: str
+          :return:  JSON document
+          :rtype: dict
 
-         """
+          """
         headers = {HEADER_TOKEN: self.token, 'Content-Type': 'application/json;charset=UTF-8'}
         url = f'{self.protocol}://{self.server}/api/metadata/groups/'
-        with self.session.post(url, headers=headers, data=json_document) as request:
-            if request.status_code == requests.codes.unauthorized:
-                self.token = self.__token__()
-                return self.add_group_json(json_document)
-            elif request.status_code == requests.codes.created:
-                return json.loads(str(request.content.decode('utf-8')))
-            else:
-                exception = HTTPException(None, request.status_code, request.url, "add_group_json",
-                                          request.content.decode('utf-8'))
-                logger.error(exception)
-                raise exception
 
-    def group_json(self, group_id: str) -> str:
+        if isinstance(json_object, dict):
+            with self.session.post(url, headers=headers, json=json_object) as request:
+                if request.status_code == requests.codes.unauthorized:
+                    self.token = self.__token__()
+                    return self.add_group_json(json_object)
+                elif request.status_code == requests.codes.created:
+                    return json.loads(str(request.content.decode('utf-8')))
+                else:
+                    exception = HTTPException(None, request.status_code, request.url, "add_group_json",
+                                              request.content.decode('utf-8'))
+                    logger.error(exception)
+                    raise exception
+
+        elif isinstance(json_object, str):
+            with self.session.post(url, headers=headers, data=json_object) as request:
+                if request.status_code == requests.codes.unauthorized:
+                    self.token = self.__token__()
+                    return self.add_group_json(json_object)
+                elif request.status_code == requests.codes.created:
+                    return json.loads(str(request.content.decode('utf-8')))
+                else:
+                    exception = HTTPException(None, request.status_code, request.url, "add_group_json",
+                                              request.content.decode('utf-8'))
+                    logger.error(exception)
+                    raise exception
+        else:
+            raise RuntimeError("Argument must be a JSON dictionary or a JSON str")
+
+    def group_json(self, group_id: str) -> dict:
         """
-         Return a Group as a JSON document
+         Return a Group as a JSON object
 
          :param group_id: The Group id
          :type group_id: str
 
          :return:  JSON document
-         :rtype: str
+         :rtype: dict
 
          """
         headers = {HEADER_TOKEN: self.token, 'Content-Type': 'application/json;charset=UTF-8'}
@@ -213,7 +305,7 @@ class MetadataGroupsAPI(AuthenticatedAPI):
                 self.token = self.__token__()
                 return self.group_json(group_id)
             elif request.status_code == requests.codes.ok:
-                return str(request.content.decode('utf-8'))
+                return json.loads(str(request.content.decode('utf-8')))
             else:
                 exception = HTTPException(None, request.status_code, request.url, "group_json",
                                           request.content.decode('utf-8'))
@@ -222,47 +314,24 @@ class MetadataGroupsAPI(AuthenticatedAPI):
 
     def group(self, group_id: str) -> Group:
         """
-         Return a Group object by its id
+         Return a Group object by its ID
 
          :param group_id: The Group id
          :type group_id: str
 
-         :return: The Group
+         :return:  The metadata Group Object
          :rtype: Group
 
          """
-        json_group = json.loads(self.group_json(group_id))
-        group: Group = Group()
-        group.group_id = json_group['id']
-        group.name = json_group['name']
-        group.description = json_group['description']
-        group.schemaUri = json_group['schemaUri']
-
-        for f in json_group['fields']:
-            gf: GroupField = GroupField(f['id'], f['name'])
-            if 'type' in f:
-                gf.field_type = f['type']
-            if 'visible' in f:
-                gf.visible = f['visible']
-            if 'editable' in f:
-                gf.editable = f['editable']
-            if 'indexed' in f:
-                gf.indexed = f['indexed']
-            if 'maxOccurs' in f:
-                gf.maxOccurs = f['maxOccurs']
-            if 'minOccurs' in f:
-                gf.minOccurs = f['minOccurs']
-            if 'values' in f:
-                gf.values = f['values']
-            group.fields.append(gf)
-        return group
 
-    def groups_json(self) -> str:
+        return _object_from_json_(self.group_json(group_id))
+
+    def groups_json(self) -> List[dict]:
         """
-        Return all the groups in the tenancy as a single json document
+        Return all the metadata Groups in the tenancy as a list of JSON dict objects
 
-        :return: JSON document
-        :rtype: str
+        :return: List of JSON dictionary object
+        :rtype: List[dict]
 
         """
 
@@ -273,28 +342,21 @@ class MetadataGroupsAPI(AuthenticatedAPI):
                 self.token = self.__token__()
                 return self.groups_json()
             elif request.status_code == requests.codes.ok:
-                return str(request.content.decode('utf-8'))
+                return json.loads(str(request.content.decode('utf-8')))['groups']
             else:
                 exception = HTTPException(None, request.status_code, request.url, "groups_json",
                                           request.content.decode('utf-8'))
                 logger.error(exception)
                 raise exception
 
-    def groups(self) -> List[Group]:
+    def groups(self) -> Generator[Group, None, None]:
         """
-        Return all the groups in the tenancy
+        Return all the metadata Groups in the tenancy as Group Objects
 
-        :return: list of Groups
-        :rtype: List[Group]
+        :return: Generator of Group Objects
+        :rtype: Group
 
         """
-        groups = json.loads(self.groups_json())['groups']
-        return_groups = []
-        for g in groups:
-            group: Group = Group()
-            group.group_id = g['id']
-            group.name = g['name']
-            group.description = g['description']
-            group.schemaUri = g['schemaUri']
-            return_groups.append(group)
-        return return_groups
+
+        for group in self.groups_json():
+            yield _object_from_json_(group)

{pypreservica-2.8.0 → pypreservica-2.8.2}/pyPreservica.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyPreservica
-Version: 2.8.0
+Version: 2.8.2
 Summary: Python library for the Preservica API
 Home-page: https://pypreservica.readthedocs.io/
 Author: James Carr

{pypreservica-2.8.0 → pypreservica-2.8.2}/setup.py

@@ -21,7 +21,7 @@ if sys.argv[-1] == 'publish':
 # This call to setup() does all the work
 setup(
     name=PKG,
-    version="2.8.0",
+    version="2.8.2",
     description="Python library for the Preservica API",
     long_description=README,
     long_description_content_type="text/markdown",

pypreservica-2.8.2/tests/test_groups.py

@@ -0,0 +1,97 @@
+import pytest
+from pyPreservica import *
+
+
+def test_cam_get_all_groups_as_objects():
+    client = MetadataGroupsAPI()
+    assert len(list(client.groups())) > 0
+    for g in client.groups():
+        assert isinstance(g, Group)
+        assert g.group_id is not None
+        assert g.name is not None
+        assert g.schemaUri is not None
+
+
+def test_cam_get_all_groups_as_JSON():
+    client = MetadataGroupsAPI()
+    for g in client.groups_json():
+        if g['name'] == "digiteek":
+            assert g['schemaUri'] == 'http://www.preservica.com/metadata/group/digiteek'
+        if g['name'] == 'McD Metadata':
+            assert g['schemaUri'] == 'http://www.preservica.com/metadata/group/mcd_metadata'
+
+
+def test_can_get_group():
+    client = MetadataGroupsAPI()
+    for g in client.groups():
+        if g.name == "digiteek":
+            full_group: Group = client.group(g.group_id)
+            assert full_group.name == "digiteek"
+            assert full_group.description == "digiteek"
+            assert len(full_group.fields) == 19
+            break
+
+
+def test_can_add_group_by_object():
+    client = MetadataGroupsAPI()
+    group1: Group = Group("my_group_name1", "my_group_description1")
+    group1.fields.append(GroupField(field_id="attribute_1", name="Attribute 1x", field_type=GroupFieldType.STRING))
+    group1.fields.append(GroupField(field_id="attribute_2", name="Attribute 2x", field_type=GroupFieldType.NUMBER))
+    group1.fields.append(GroupField(field_id="attribute_3", name="Attribute 3x", field_type=GroupFieldType.DATE))
+
+    g1: dict = client.add_group(group1.name, group1.description, group1.fields)
+
+    assert g1['name'] == group1.name
+    assert g1['description'] == group1.description
+
+    assert len(g1['fields']) == 3
+
+    group1: Group = client.group(g1['id'])
+
+    client.delete_group(group1.group_id)
+
+
+def test_can_add_new_fields_to_group():
+    client = MetadataGroupsAPI()
+
+    group2: Group = Group("test_group_1", "test_group_1_description")
+
+    assert len(group2.fields) == 0
+
+    group2.fields.append(GroupField(field_id="attribute_11", name="Attribute 11", field_type=GroupFieldType.STRING))
+    group2.fields.append(GroupField(field_id="attribute_22", name="Attribute 22", field_type=GroupFieldType.NUMBER))
+    group2.fields.append(GroupField(field_id="attribute_33", name="Attribute 33", field_type=GroupFieldType.DATE))
+
+    assert len(group2.fields) == 3
+
+    g2: dict = client.add_group(group2.name, group2.description, group2.fields)
+
+    assert g2['name'] == group2.name
+    assert g2['description'] == group2.description
+
+    assert len(g2['fields']) == 3
+
+    group_id = g2['id']
+
+    group3: Group = client.group(group_id)
+
+    assert g2['name'] == group3.name
+    assert g2['description'] == group3.description
+
+    new_fields = []
+
+    new_fields.append(GroupField(field_id="attribute_4", name="Attribute 4", field_type=GroupFieldType.LONG_STRING))
+    new_fields.append(GroupField(field_id="attribute_5", name="Attribute 5", field_type=GroupFieldType.NUMBER))
+
+    client.add_fields(group_id, new_fields)
+
+    group4: Group = client.group(group_id)
+
+    assert len(group4.fields) == 5
+
+    client.delete_group(group_id)
+
+
+def test_can_get_group_by_URI():
+    client = MetadataGroupsAPI()
+    uri = "http://www.preservica.com/metadata/group/mcd_metadata"

pypreservica-2.8.0/tests/test_groups.py

@@ -1,8 +0,0 @@
-import pytest
-from pyPreservica import *
-
-
-def test_cam_get_all_groups():
-    client = MetadataGroupsAPI()
-    for g in client.groups():
-        assert isinstance(g, Group)