annolab 0.3.2__py3-none-any.whl

annolab/__init__.py

@@ -0,0 +1,6 @@
+
+# Configuration
+api_key = None
+
+from annolab.annolab import AnnoLab
+from annolab.project import Project

annolab/annolab.py

@@ -0,0 +1,76 @@
+from annolab.project_import import ProjectImport
+import os
+
+from annolab import endpoints
+from annolab.project import Project
+from annolab.api_helper import ApiHelper
+
+class AnnoLab:
+
+  def __init__(
+    self,
+    api_key = None,
+    api_url = 'https://api.annolab.ai',
+  ):
+    self.__api = ApiHelper(api_key=api_key, api_url=api_url)
+
+  @property
+  def api_key_info(self):
+    return self.__api.api_key_info
+
+
+  @property
+  def default_owner(self):
+    """
+      Returns the default group to use for the api key.
+      The default group is the group representing the single user.
+    """
+    return self.__api.default_owner
+
+
+  def find_project(self, name: str, owner_name: str = None):
+    """
+      Find a project by name and (optionally) group name.
+      If group name is not passed, the user's default group is used.
+    """
+    owner_name = owner_name or self.default_owner['groupName']
+
+    res = self.__api.get_request(
+      endpoints.Project.get_group_project(owner_name, name)
+    )
+
+    return Project.create_from_response_json(res.json(), self.__api)
+
+
+  def create_project(self, name: str, owner_name: str = None, is_public = False):
+    """
+      Create a project.
+      If group name is not passed, the user's default group is used.
+    """
+    owner_name = owner_name or self.default_owner['groupName']
+
+    res = self.__api.post_request(
+      endpoints.Project.post_create(),
+      {
+        'name': name,
+        'groupName': owner_name,
+        'isPublic': is_public
+      }
+    )
+
+    return Project.create_from_response_json(res.json(), self.__api)
+
+
+  def create_project_from_export(self, filepath: str, name: str = None, owner_name: str = None, is_public=False):
+    if (name is None):
+      name = os.path.basename(filepath).split('.')[0]
+
+    project = self.create_project(name, owner_name, is_public=is_public)
+    project_import = ProjectImport(filepath, project, owner_name)
+
+    project_import.unzip_export()
+    project_import.import_all()
+    project_import.cleanup()
+
+    return project
+

annolab/annotation.py

@@ -0,0 +1,37 @@
+from typing import Dict
+
+class Annotation:
+
+  @staticmethod
+  def create_api_annotation(dict: Dict):
+    """
+    Maps an sdk annotation dict to an api annotation dict, for use in calls to the api.
+
+    Annotation parameters:
+      type:       str  (Required)
+      client_id:  str  (Optional, Required if passing relations)
+      value:      str  (Optional)
+      offsets:    [int, int] (Optional)
+      text_bounds { 'type': 'Polygon', coordinates: List[List[List[int]]] } (Optional)
+      bbox:       [int, int, int, int] (Optional, Ignored if text_bounds are passed)
+      layer:      str  (Optional)
+      page:       int  (Optional)
+      reviewed    bool (Optional)
+    """
+    annotation = { 'annoTypeIdentifier': dict['type'] }
+
+    if ('client_id' in dict): annotation['clientId'] = str(dict['client_id'])
+    if ('offsets' in dict): annotation['offsets'] = dict['offsets']
+    if ('value' in dict): annotation['value'] = dict['value']
+    if ('bbox' in dict): annotation['bbox'] = dict['bbox']
+    if ('text_bounds' in dict): annotation['textBounds'] = dict['text_bounds']
+    if ('image_bounds' in dict): annotation['imageBounds'] = dict['image_bounds']
+    if ('layer' in dict): annotation['layerIdentifier'] = dict['layer']
+    if ('page' in dict): annotation['pageNumber'] = dict['page']
+    if ('endPage' in dict): annotation['endPageNumber'] = dict['endPage']
+    if ('reviewed' in dict): annotation['isReviewed'] = dict['reviewed']
+    if ('source' in dict): annotation['sourceIdentifier'] = dict['source']
+    if ('directory' in dict): annotation['directoryIdentifier'] = dict['directory']
+    if ('project' in dict): annotation['projectIdentifier'] = dict['project']
+
+    return annotation

annolab/annotation_relation.py

@@ -0,0 +1,28 @@
+from typing import Dict
+
+
+class AnnotationRelation:
+
+  @staticmethod
+  def create_api_relation(dict: Dict):
+    """
+    Maps an sdk relation dict to an api annotation relation dict, for use in calls to the api.
+
+    AnnotationRelation parameters:
+      annotations:      [Union[str, int], Union[str, int]]
+      type:             str
+      value:            str
+      reviewed          bool (Optional)
+      project           Union[str, int]
+    """
+    relation = {
+      'predecessorId': str(dict['annotations'][0]),
+      'successorId': str(dict['annotations'][1])
+    }
+
+    if ('type' in dict): relation['annoTypeIdentifier'] = dict['type']
+    if ('value' in dict): relation['value'] = dict['value']
+    if ('reviewed' in dict): relation['isReviewed'] = dict['reviewed']
+    if ('project' in dict): relation['projectIdentifier'] = dict['project']
+
+    return relation

annolab/api_helper.py

@@ -0,0 +1,97 @@
+from typing import Dict, Any
+import requests
+from urllib import parse
+import logging
+from requests.models import Response
+
+import annolab
+from annolab import endpoints
+from annolab.util.cached_property import cached_property
+
+class ApiHelper(object):
+
+  def __init__(
+    self,
+    api_key = None,
+    api_url = 'https://api.annolab.ai',
+  ):
+    self.api_url = api_url
+    self.api_key = api_key or annolab.api_key
+
+
+  @property
+  def __auth_header(self, key: str = None):
+    key = key or self.api_key
+    return { 'Authorization': f'Api-Key {key}' }
+
+
+  @cached_property
+  def api_key_info(self):
+    return self.get_request(endpoints.ApiKey.get_api_key_info()).json()
+
+
+  '''
+    Returns the default group to use for the api key.
+    The default group is the group representing the single user.
+  '''
+  @cached_property
+  def default_owner(self):
+    default_owner = None
+    for group in self.api_key_info['groups']:
+      if (group['isSingleUser'] is True):
+        default_owner = group
+
+    return default_owner
+
+
+  def get_request(self, path: str, body: Dict[str, Any] = None, params: dict = None) -> Response:
+    resp = requests.get(
+      parse.urljoin(self.api_url, path),
+      headers=self.__auth_header,
+      json=body
+    )
+
+    self.__handle_non_2xx_response(resp)
+
+    return resp
+
+
+  def post_request(self, path: str, body: Dict[str, Any] = None, params: dict = None, timeout: float = 30.0):
+    resp = requests.post(
+      parse.urljoin(self.api_url, path),
+      headers=self.__auth_header,
+      json=body,
+      params=params,
+      timeout=timeout
+    )
+
+    self.__handle_non_2xx_response(resp)
+
+    return resp
+
+
+  def put_request(self, path: str, data: Any = None, headers = None, params: dict = None, timeout: float = 30.0):
+    resp = requests.put(
+      parse.urljoin(self.api_url, path),
+      headers=headers,
+      data=data,
+      params=params,
+      timeout=timeout
+    )
+
+    self.__handle_non_2xx_response(resp)
+
+    return resp
+
+
+  def __handle_non_2xx_response(self, resp: Response):
+    if (resp.status_code >= 300):
+      try:
+        resp_body = resp.json()
+      except:
+        resp_body = {}
+
+      message = resp_body['message'] if 'message' in resp_body else 'Unknown Error'
+
+      logging.error(f'{resp.request.method} {resp.request.path_url} failed with message: {message}')
+      resp.raise_for_status()

annolab/endpoints.py

@@ -0,0 +1,114 @@
+class Project:
+
+  @staticmethod
+  def post_create():
+    return 'v1/project/create'
+
+
+  @staticmethod
+  def get_group_project(groupName: str, projectName: str):
+    return f'v1/project/{groupName}/{projectName}'
+
+
+  @staticmethod
+  def get_using_id(id: int):
+    return f'v1/project/{id}'
+
+
+class Export:
+
+  @staticmethod
+  def post_export_project():
+    return 'v1/export/project'
+
+
+class Directory:
+
+  @staticmethod
+  def post_create():
+    return 'v1/directory/create'
+
+
+class Annotation:
+
+  @staticmethod
+  def post_create():
+    return 'v1/annotation/create'
+
+  @staticmethod
+  def post_bulk_create():
+    return 'v1/annotation/bulk-create'
+
+
+class AnnotationType:
+
+  @staticmethod
+  def post_create():
+    return 'v1/annotation-type/create'
+
+
+class AnnotationRelation:
+
+  @staticmethod
+  def post_create():
+    return 'v1/relation/create'
+
+
+  @staticmethod
+  def post_bulk_create():
+    return 'v1/relation/bulk-create'
+
+
+class AnnotationLayer:
+
+  @staticmethod
+  def post_create():
+    return 'v1/layer/create'
+
+
+class Source:
+
+  @staticmethod
+  def get_source_by_id(source_ref_id: int):
+    return f'v1/source/{source_ref_id}'
+
+
+  @staticmethod
+  def get_source_by_path(owner_name: str, project_name: str, directory_name: str, source_ref_name: str):
+    return f'v1/source/{owner_name}/{project_name}/{directory_name}/{source_ref_name}'
+
+
+  @staticmethod
+  def post_create_text():
+    return 'v1/source/create-text'
+
+
+  @staticmethod
+  def post_initialize_pdf():
+    return 'v1/source/init-pdf'
+
+
+  @staticmethod
+  def post_create_pdf():
+    return 'v1/source/create-pdf'
+
+
+  @staticmethod
+  def post_annotations(owner_name: str, project_name: str, directory_name: str, source_ref_name: str):
+    return f'v1/source/{owner_name}/{project_name}/{directory_name}/{source_ref_name}/annotations'
+
+
+  @staticmethod
+  def delete_using_name(owner_name: str, project_name: str, directory_name: str, source_ref_name: str):
+    return f'v1/source/{owner_name}/{project_name}/{directory_name}/{source_ref_name}'
+
+
+  @staticmethod
+  def delete_using_id(id: int):
+    return f'v1/source/{id}'
+
+
+class ApiKey:
+  @staticmethod
+  def get_api_key_info():
+    return 'v1/api-key/info'