dsp-tools 0.9.13__py3-none-any.whl → 18.3.0.post13__py3-none-any.whl

knora/dsp_tools.py

@@ -1,96 +0,0 @@
-import argparse
-import sys
-import os
-
-sys.path.append(os.path.dirname(os.path.realpath(__file__)))
-
-from dsplib.utils.onto_validate import validate_list, validate_ontology
-from dsplib.utils.onto_create_lists import create_lists
-from dsplib.utils.onto_create_ontology import create_ontology
-from dsplib.utils.onto_get import get_ontology
-from dsplib.utils.xml_upload import xml_upload
-
-
-def program(args):
-    #
-    # parse the arguments of the command line
-    #
-    parser = argparse.ArgumentParser(
-        description="A program to create and manipulate ontologies based on the DaSCH Service Platform"
-    )
-
-    subparsers = parser.add_subparsers(title="Subcommands",
-                                       description='Valid subcommands are',
-                                       help='sub-command help')
-
-    parser_create = subparsers.add_parser('create', help='Create ontologies, lists etc.')
-    parser_create.set_defaults(action="create")
-    parser_create.add_argument("-s", "--server", type=str, default="http://0.0.0.0:3333", help="URL of the DSP server")
-    parser_create.add_argument("-u", "--user", default="root@example.com", help="Username for DSP server")
-    parser_create.add_argument("-p", "--password", default="test", help="The password for login")
-    parser_create.add_argument("-V", "--validate", action='store_true', help="Do only validation of JSON, no upload of the ontology")
-    parser_create.add_argument("datamodelfile", help="path to data model file")
-    parser_create.add_argument("-L", "--listfile", type=str, default="lists.json", help="Name of list node informationfile")
-    parser_create.add_argument("-l", "--lists", action='store_true', help="Only create the lists")
-    parser_create.add_argument("-v", "--verbose", action="store_true", help="Verbose feedback")
-    parser_create.add_argument("-d", "--dump", action="store_true", help="dump test files for DSP-API requests")
-
-    parser_get = subparsers.add_parser('get', help='Get project/ontology information from server')
-    parser_get.set_defaults(action="get")
-    parser_get.add_argument("-u", "--user", default="root@example.com", help="Username for DSP server")
-    parser_get.add_argument("-p", "--password", default="test", help="The password for login")
-    parser_get.add_argument("-s", "--server", type=str, default="http://0.0.0.0:3333", help="URL of the DSP server")
-    parser_get.add_argument("-P", "--project", type=str, help="Shortcode, shortname or iri of project", required=True)
-    parser_get.add_argument("outfile", help="path to data model file", default="onto.json")
-    parser_get.add_argument("-v", "--verbose", action="store_true", help="Verbose feedback")
-
-    parser_upload = subparsers.add_parser('xmlupload', help='Upload data from XML file to server')
-    parser_upload.set_defaults(action="xmlupload")
-    parser_upload.add_argument("-s", "--server", type=str, default="http://0.0.0.0:3333", help="URL of the DSP server")
-    parser_upload.add_argument("-u", "--user", type=str, default="root@example.com", help="Username for DSP server")
-    parser_upload.add_argument("-p", "--password", type=str, default="test", help="The password for login")
-    parser_upload.add_argument("-V", "--validate", action='store_true', help="Do only validation of JSON, no upload of the ontology")
-    parser_upload.add_argument("-i", "--imgdir", type=str, default=".", help="Path to folder containing the images")
-    parser_upload.add_argument("-S", "--sipi", type=str, default="http://0.0.0.0:1024", help="URL of SIPI server")
-    parser_upload.add_argument("xmlfile", help="path to xml file containing the data", default="data.xml")
-    parser_upload.add_argument("-v", "--verbose", action="store_true", help="Verbose feedback")
-
-    args = parser.parse_args(args)
-
-    if not hasattr(args, 'action'):
-        parser.print_help(sys.stderr)
-        exit(0)
-
-    if args.action == "create":
-        if args.lists:
-            if args.validate:
-                validate_list(args.datamodelfile)
-            else:
-                create_lists(args.datamodelfile, args.dump)
-        else:
-            if args.validate:
-                validate_ontology(args.datamodelfile)
-            else:
-                create_ontology(args.datamodelfile, args.listfile, args.server, args.user, args.password, args.verbose,
-                                args.dump if args.dump else False)
-    elif args.action == "get":
-        get_ontology(args.project, args.outfile, args.server, args.user, args.password, args.verbose)
-    elif args.action == "xmlupload":
-        xml_upload(input_file=args.xmlfile,
-                   server=args.server,
-                   user=args.user,
-                   password=args.password,
-                   imgdir=args.imgdir,
-                   sipi=args.sipi,
-                   verbose=args.verbose,
-                   validate=args.validate)
-
-
-
-def main():
-    program(sys.argv[1:])
-
-
-if __name__ == '__main__':
-    program(sys.argv[1:])
-

knora/dsplib/models/connection.py

@@ -1,272 +0,0 @@
-import requests
-import json
-from pystrict import strict
-from typing import List, Set, Dict, Tuple, Optional, Any, Union
-
-from .helpers import Actions, BaseError
-
-@strict
-class Connection:
-    """
-    An Connection instance represents a connection to a Knora server.
-
-    Attributes
-    ----------
-
-    none (internal use attributes should not be modified/set directly)
-    """
-
-    _server: str
-    _prefixes: Union[Dict[str, str], None]
-    _token: Union[str, None]
-    _log: bool
-
-    def __init__(self, server: str, prefixes: Dict[str, str] = None):
-        """
-        Constructor requiring the server address, the user and password of KNORA
-        :param server: Address of the server, e.g https://api.dasch.swiss
-        :param prefixes: Ontology prefixes used
-        """
-
-        self._server = server
-        self._prefixes = prefixes
-        self._token = None
-        self._log = False
-
-    def login(self, email: str, password: str) -> None:
-        """
-        Method to login into KNORA which creates a session token.
-        :param email: Email of user, e.g., root@example.com
-        :param password: Password of the user, e.g. test
-        """
-
-        credentials = {
-            "email": email,
-            "password": password
-        }
-        jsondata = json.dumps(credentials)
-
-        req = requests.post(
-            self._server + '/v2/authentication',
-            headers={'Content-Type': 'application/json; charset=UTF-8'},
-            data=jsondata
-        )
-        self.on_api_error(req)
-        result = req.json()
-        self._token = result["token"]
-
-    def get_token(self) -> str:
-        """
-        Returns the token
-        :return: token string
-        """
-
-        return self._token
-
-    def start_logging(self):
-        self._log = True
-
-    def stop_logging(self):
-        self._log = False
-
-    def logout(self) -> None:
-        """
-        Performs a logout
-        :return: None
-        """
-
-        if self._token is not None:
-            req = requests.delete(
-                self._server + '/v2/authentication',
-                headers={'Authorization': 'Bearer ' + self._token}
-            )
-            self.on_api_error(req)
-            self._token = None
-
-    def __del__(self):
-        pass
-        #self.logout()
-
-    def on_api_error(self, res) -> None:
-        """
-        Method to check for any API errors
-        :param res: The input to check, usually JSON format
-        :return: Possible Error that is being raised
-        """
-
-        if res.status_code != 200:
-            raise BaseError("KNORA-ERROR: status code=" + str(res.status_code) + "\nMessage:" + res.text)
-
-        if 'error' in res:
-            raise BaseError("KNORA-ERROR: API error: " + res.error)
-
-    def post(self, path: str, jsondata: Optional[str] = None):
-        """
-        Post Json data to a given server using a HTTP POST request
-        :param path: Path of RESTful route
-        :param jsondata: Valid JSON as string
-        :return: Response from server
-        """
-
-        if path[0] != '/':
-            path = '/' + path
-        headers = None
-        if jsondata is None:
-            if self._token is not None:
-                headers = {'Authorization': 'Bearer ' + self._token}
-                req = requests.post(self._server + path,
-                                    headers=headers)
-            else:
-                req = requests.post(self._server + path)
-        else:
-            if self._token is not None:
-                headers = {'Content-Type': 'application/json; charset=UTF-8',
-                           'Authorization': 'Bearer ' + self._token}
-                req = requests.post(self._server + path,
-                                    headers=headers,
-                                    data=jsondata)
-            else:
-                headers = {'Content-Type': 'application/json; charset=UTF-8'}
-                req = requests.post(self._server + path,
-                                    headers=headers,
-                                    data=jsondata)
-        if self._log:
-            if jsondata:
-                jsonobj = json.loads(jsondata)
-            else:
-                jsonobj = None
-            logobj = {
-                "method": "POST",
-                "headers": headers,
-                "route": path,
-                "body": jsonobj,
-                "return-headers": dict(req.headers),
-                "return": req.json() if req.status_code == 200 else {"status": str(req.status_code),
-                                                                     "message": req.text}
-            }
-            tmp = path.split('/')
-            filename = "POST" + "_".join(tmp) + ".json"
-            with open(filename, 'w') as f:
-                json.dump(logobj, f, indent=3)
-        self.on_api_error(req)
-        result = req.json()
-        return result
-
-    def get(self, path: str, headers: Optional[Dict[str, str]] = None):
-        """
-        Get data from a server using a HTTP GET request
-        :param path: Path of RESTful route
-        :param headers: ...
-        :return: Response from server
-        """
-
-        if path[0] != '/':
-            path = '/' + path
-        if self._token is None:
-            if headers is None:
-                req = requests.get(self._server + path)
-            else:
-                req = requests.get(self._server + path, headers)
-        else:
-            if headers is None:
-                req = requests.get(self._server + path,
-                                   headers={'Authorization': 'Bearer ' + self._token})
-            else:
-                headers['Authorization'] = 'Bearer ' + self._token
-                req = requests.get(self._server + path, headers)
-
-        self.on_api_error(req)
-        result = req.json()
-        return result
-
-    def put(self, path: str, jsondata: Optional[str] = None, content_type: str = 'application/json'):
-        """
-        Send data to a RESTful server using a HTTP PUT request
-        :param path: Path of RESTful route
-        :param jsondata: Valid JSON as string
-        :param content_type: HTTP Content-Type [default: 'application/json']
-        :return:
-        """
-
-        if path[0] != '/':
-            path = '/' + path
-        if jsondata is None:
-            req = requests.put(self._server + path,
-                               headers={'Authorization': 'Bearer ' + self._token})
-        else:
-            req = requests.put(self._server + path,
-                               headers={'Content-Type': content_type + '; charset=UTF-8',
-                                        'Authorization': 'Bearer ' + self._token},
-                               data=jsondata)
-        self.on_api_error(req)
-        result = req.json()
-        return result
-
-    def delete(self, path: str, params: Optional[any] = None):
-        """
-        Send a delete request using the HTTP DELETE request
-        :param path: Path of RESTful route
-        :return: Response from server
-        """
-
-        if path[0] != '/':
-            path = '/' + path
-        if params is not None:
-            req = requests.delete(self._server + path,
-                                  headers={'Authorization': 'Bearer ' + self._token},
-                                  params=params)
-
-        else:
-            req = requests.delete(self._server + path,
-                                  headers={'Authorization': 'Bearer ' + self._token})
-        self.on_api_error(req)
-        result = req.json()
-        return result
-
-    def reset_triplestore_content(self):
-        rdfdata = [
-            {
-                "path": "./knora-ontologies/knora-admin.ttl",
-                "name": "http://www.knora.org/ontology/knora-admin"
-            },
-            {
-                "path": "./knora-ontologies/knora-base.ttl",
-                "name": "http://www.knora.org/ontology/knora-base"
-            },
-            {
-                "path": "./knora-ontologies/standoff-onto.ttl",
-                "name": "http://www.knora.org/ontology/standoff"
-            },
-            {
-                "path": "./knora-ontologies/standoff-data.ttl",
-                "name": "http://www.knora.org/data/standoff"
-            },
-            {
-                "path": "./knora-ontologies/salsah-gui.ttl",
-                "name": "http://www.knora.org/ontology/salsah-gui"
-            },
-            {
-                "path": "./_test_data/all_data/admin-data.ttl",
-                "name": "http://www.knora.org/data/admin"
-            },
-            {
-                "path": "./_test_data/all_data/permissions-data.ttl",
-                "name": "http://www.knora.org/data/permissions"
-            },
-            {
-                "path": "./_test_data/all_data/system-data.ttl",
-                "name": "http://www.knora.org/data/0000/SystemProject"
-            }
-        ]
-        jsondata = json.dumps(rdfdata)
-        url = self._server + '/admin/store/ResetTriplestoreContent?prependdefaults=false'
-
-        req = requests.post(url,
-                            headers={'Content-Type': 'application/json; charset=UTF-8'},
-                            data=jsondata)
-        self.on_api_error(req)
-        res = req.json()
-        #  pprint(res)
-        return res
-
-

knora/dsplib/models/group.py

@@ -1,296 +0,0 @@
-import json
-from pystrict import strict
-from typing import List, Set, Dict, Tuple, Optional, Any, Union
-from urllib.parse import quote_plus
-
-from .helpers import Actions, BaseError
-from .connection import Connection
-from .model import Model
-from .project import Project
-
-"""
-This module implements the handling (CRUD) of Knora groups.
-
-CREATE:
-    * Instantiate a new object of the class Group with all required parameters
-    * Call the ``create``-method on the instance
-
-READ:
-    * Instantiate a new object with ``id``(IRI of group) given
-    * Call the ``read``-method on the instance
-    * Access the information that has been provided to the instance
-
-UPDATE:
-    * You need an instance of an existing Project by reading an instance
-    * Change the attributes by assigning the new values
-    * Call the ``update```method on the instance
-
-DELETE
-    * Instantiate a new objects with ``id``(IRI of group) given, or use any instance that has the id set
-    * Call the ``delete``-method on the instance
-
-"""
-@strict
-class Group(Model):
-    """
-    This class represents a Knora group
-
-    Attributes
-    ----------
-
-    con : Connection
-        A connection instance to a Knora server
-
-    id : str
-        IRI of the group [get only, cannot be modified after creation of instance]
-
-    name : str
-        Name of the group
-
-    description : str
-        A description of the group
-
-    project : str | project
-        either the IRI of a project [get only, cannot be modified after creation of instance]
-        or an valid Project instance
-
-    selfjoin : boolean
-        A flag indicating if selfjoin is allowed in this group
-
-    status : boolean
-        A flag indicating if the group is active (True) or inactive/makred deleted (False)
-
-    """
-
-    PROJECT_MEMBER_GROUP: str = "http://www.knora.org/ontology/knora-admin#ProjectMember"
-    PROJECT_ADMIN_GROUP: str = "http://www.knora.org/ontology/knora-admin#ProjectAdmin"
-    PROJECT_SYSTEMADMIN_GROUP: str = "http://www.knora.org/ontology/knora-admin#SystemAdmin"
-
-    _id: str
-    _name: str
-    _description: str
-    _project: str
-    _selfjoin: bool
-    _status: bool
-
-    def __init__(self,
-                 con: Connection,
-                 id: Optional[str] = None,
-                 name: Optional[str] = None,
-                 description: Optional[str] = None,
-                 project: Optional[Union[str, Project]] = None,
-                 selfjoin: Optional[bool] = None,
-                 status: Optional[bool] = None):
-        super().__init__(con)
-        self._id = str(id) if id is not None else None
-        self._name = str(name) if name is not None else None
-        self._description = description
-        if project is not None and isinstance(project, Project):
-            self._project = project.id
-        else:
-            self._project = str(project) if project is not None else None
-        self._selfjoin = bool(selfjoin) if selfjoin is not None else None
-        self._status = bool(status) if status is not None else None
-
-    @property
-    def id(self) -> Optional[str]:
-        return self._id
-
-    @id.setter
-    def id(self, value: str) -> None:
-        raise BaseError('Group id cannot be modified!')
-
-    @property
-    def name(self) -> Optional[str]:
-        return self._name
-
-    @name.setter
-    def name(self, value: str):
-        self._name = value
-        self._changed.add('name')
-
-    @property
-    def description(self):
-        return self._description
-
-    @description.setter
-    def description(self, value: Optional[str]):
-        self._description = value
-        self._changed.add('description')
-
-    @property
-    def project(self):
-        return self._project
-
-    @project.setter
-    def project(self, value: str):
-        raise BaseError('project id cannot be modified!')
-
-    @property
-    def selfjoin(self) -> bool:
-        return self._selfjoin
-
-    @selfjoin.setter
-    def selfjoin(self, value: bool) -> None:
-        self._selfjoin = value
-        self._changed.add('selfjoin')
-
-    @property
-    def status(self) -> bool:
-        return self._status
-
-    @status.setter
-    def status(self, value: bool) -> None:
-        self._status = value
-        self._changed.add('status')
-
-    def has_changed(self) -> bool:
-        if self._changed:
-            return True
-        else:
-            return False
-
-    @classmethod
-    def fromJsonObj(cls, con: Connection, json_obj: Any):
-        id = json_obj.get('id')
-        if id is None:
-            raise BaseError('Group "id" is missing in JSON from knora')
-        name = json_obj.get('name')
-        if name is None:
-            raise BaseError('Group "name" is missing in JSON from knora')
-        description = json_obj.get('description')
-        tmp = json_obj.get('project')
-        if tmp is None:
-            raise BaseError('Group "project" is missing in JSON from knora')
-        project = tmp.get('id')
-        if project is None:
-            raise BaseError('Group "project" has no "id" in JSON from knora')
-        selfjoin = json_obj.get('selfjoin')
-        if selfjoin is None:
-            raise BaseError("selfjoin is missing in JSON from knora")
-        status = json_obj.get('status')
-        if status is None:
-            raise BaseError("Status is missing in JSON from knora")
-        return cls(con=con,
-                   name=name,
-                   id=id,
-                   description=description,
-                   project=project,
-                   selfjoin=selfjoin,
-                   status=status)
-
-    def toJsonObj(self, action: Actions):
-        tmp = {}
-        if action == Actions.Create:
-            if self._name is None:
-                raise BaseError("There must be a valid name!")
-            tmp['name'] = self._name
-            if self._description is not None:
-                tmp['description'] = self._description
-            if self._project is None:
-                raise BaseError("There must be a valid project!")
-            tmp['project'] = self._project
-            if self._selfjoin is None:
-                raise BaseError("There must be a valid value for selfjoin!")
-            tmp['selfjoin'] = self._selfjoin
-            if self._status is None:
-                raise BaseError("There must be a valid value for status!")
-            tmp['status'] = self._status
-        else:
-            if self._name is not None and 'name' in self._changed:
-                tmp['name'] = self._name
-            if self._description is not None and 'description' in self._changed:
-                tmp['description'] = self._description
-            if self._selfjoin is not None and 'selfjoin' in self._changed:
-                tmp['selfjoin'] = self._selfjoin
-        return tmp
-
-    def create(self):
-        jsonobj = self.toJsonObj(Actions.Create)
-        jsondata = json.dumps(jsonobj)
-        result = self._con.post('/admin/groups', jsondata)
-        return Group.fromJsonObj(self._con, result['group'])
-
-    def read(self):
-        result = self._con.get('/admin/groups/' + quote_plus(self._id))
-        return Group.fromJsonObj(self._con, result['group'])
-
-    def update(self):
-        jsonobj = self.toJsonObj(Actions.Update)
-        if jsonobj:
-            jsondata = json.dumps(jsonobj)
-            result = self._con.put('/admin/groups/' + quote_plus(self._id), jsondata)
-            updated_group = Group.fromJsonObj(self._con, result['group'])
-        if self._status is not None and 'status' in self._changed:
-            jsondata = json.dumps({'status': self._status})
-            result = self._con.put('/admin/groups/' + quote_plus(self._id) + '/status', jsondata)
-            updated_group = Group.fromJsonObj(self._con, result['group'])
-        return updated_group
-
-    def delete(self):
-        result = self._con.delete('/admin/groups/' + quote_plus(self._id))
-        return Group.fromJsonObj(self._con, result['group'])
-
-    @staticmethod
-    def getAllGroups(con: Connection) -> List['Group']:
-        result = con.get('/admin/groups')
-        if 'groups' not in result:
-            raise BaseError("Request got no groups!")
-        return list(map(lambda a: Group.fromJsonObj(con, a), result['groups']))
-
-
-    def print(self):
-        print('Group Info:')
-        print('  Id:          {}'.format(self._id))
-        print('  Name:        {}'.format(self._name))
-        print('  Description: {}'.format(self._description))
-        print('  Project:     {}'.format(self._project))
-        print('  Selfjoin:    {}'.format(self._selfjoin))
-        print('  Status:      {}'.format(self._status))
-
-
-
-if __name__ == '__main__':
-    con = Connection('http://0.0.0.0:3333')
-    con.login('root@example.com', 'test')
-
-    groups = Group.getAllGroups(con)
-    for group in groups:
-        group.print()
-
-    new_group = Group(con=con,
-                           name="KNORA-PY TEST",
-                           description="Test project for knora-py",
-                           project="http://rdfh.ch/projects/00FF",
-                           status=True,
-                           selfjoin=False).create()
-    new_group.print()
-
-    new_group.name="KNORA-PY TEST - modified"
-    new_group = new_group.update();
-    new_group.print()
-
-    new_group.description="gaga gaga gaga gaga gaga gaga gaga"
-    new_group = new_group.update();
-    new_group.print()
-
-    new_group.selfjoin = True
-    new_group = new_group.update();
-    new_group.print()
-
-    new_group.status = False
-    new_group = new_group.update();
-    new_group.print()
-
-    new_group.name = '-- KNORA-PY TEST --'
-    new_group.description = 'Final Test'
-    new_group.status = True
-    new_group = new_group.update()
-    new_group.print()
-
-    new_group.delete()
-
-    print('=========================')
-    groups = Group.getAllGroups(con)
-    for group in groups:
-        group.print()