Small tweaks in docs

Check out the CHANGELOG.md file for more information

.gitlab-ci.yml

@@ -18,43 +18,37 @@ before_script:
   stage: test
   script:
     - make -e test-$PYTHON_VERSION
+  except:
+    - tags # Avoid unnecessary double testing
     
-test-3.5:
+test-3.6:
   <<: *test_definition
   variables:
-    PYTHON_VERSION: "3.5"
+    PYTHON_VERSION: "3.6"
 
-test-2.7:
+test-3.7:
   <<: *test_definition
+  allow_failure: true
   variables:
-    PYTHON_VERSION: "2.7"
+    PYTHON_VERSION: "3.7"
 
-.image: &image_definition
+push:
   stage: push
   script:
-    - make -e push-$PYTHON_VERSION
+    - make -e push
   only:
     - tags
     - triggers
     - fix-makefiles
 
-push-3.5:
-  <<: *image_definition
-  variables:
-    PYTHON_VERSION: "3.5"
-
-push-2.7:
-  <<: *image_definition
-  variables:
-    PYTHON_VERSION: "2.7"
-
 push-latest:
-  <<: *image_definition
-  variables:
-    PYTHON_VERSION: latest
+  stage: push
+  script:
+    - make -e push-latest
   only:
     - master
     - triggers
+    - fix-makefiles
 
 push-github:
   stage: deploy
@@ -107,4 +101,3 @@ cleanup_py:
    when: always   # this is important; run even if preceding stages failed.
    script:
     - rm -vf ~/.pypirc  # we don't want to leave these around, but GitLab may clean up anyway.
-    - docker logout

.makefiles/base.mk

@@ -2,18 +2,16 @@ export
 NAME ?= $(shell basename $(CURDIR))
 VERSION ?= $(shell git describe --tags --dirty 2>/dev/null)
 
+ifeq ($(VERSION),)
+	VERSION:=unknown
+endif
+
 # Get the location of this makefile.
 MK_DIR := $(dir $(abspath $(lastword $(MAKEFILE_LIST))))
 
 -include .env
 -include ../.env
 
-.FORCE:
-
-version: .FORCE
-	@echo $(VERSION) > $(NAME)/VERSION
-	@echo $(VERSION)
-
 help:           ## Show this help.
 	@fgrep -h "##" $(MAKEFILE_LIST) | fgrep -v fgrep | sed -e 's/\\$$//' | sed -e 's/\(.*:\)[^#]*##\s*\(.*\)/\1\t\2/' | column -t -s "	"
 
@@ -35,4 +33,4 @@ include $(MK_DIR)/git.mk
 info:: ## List all variables
 	env
 
-.PHONY:: config help ci version .FORCE
+.PHONY:: config help ci

.makefiles/docker.mk

@@ -1,4 +1,14 @@
-IMAGEWTAG ?= $(IMAGENAME):$(VERSION)
+ifndef IMAGENAME
+	ifdef CI_REGISTRY_IMAGE
+		IMAGENAME=$(CI_REGISTRY_IMAGE)
+	else
+		IMAGENAME=$(NAME)
+	endif
+endif
+
+IMAGEWTAG?=$(IMAGENAME):$(VERSION)
+DOCKER_FLAGS?=$(-ti)
+DOCKER_CMD?=
 
 docker-login: ## Log in to the registry. It will only be used in the server, or when running a CI task locally (if CI_BUILD_TOKEN is set).
 ifeq ($(CI_BUILD_TOKEN),)
@@ -18,8 +28,24 @@ else
 	@docker logout
 endif
 
+docker-run: ## Build a generic docker image
+	docker run $(DOCKER_FLAGS) $(IMAGEWTAG) $(DOCKER_CMD)
+
+docker-build: ## Build a generic docker image
+	docker build . -t $(IMAGEWTAG)
+
+docker-push: docker-login ## Push a generic docker image
+	docker push $(IMAGEWTAG)
+
+docker-latest-push: docker-login ## Push the latest image
+	docker tag $(IMAGEWTAG) $(IMAGENAME)
+	docker push $(IMAGENAME)
+
 login:: docker-login
 
 clean:: docker-clean
 
+docker-info:
+	@echo IMAGEWTAG=${IMAGEWTAG}
+
 .PHONY:: docker-login docker-clean login clean

.makefiles/git.mk

@@ -14,7 +14,7 @@ push-github: ## Push the code to github. You need to set up GITHUB_DEPLOY_KEY
 ifeq ($(GITHUB_DEPLOY_KEY),)
 else
 	$(eval KEY_FILE := "$(shell mktemp)")
-	@echo "$(GITHUB_DEPLOY_KEY)" > $(KEY_FILE)
+	@printf '%b' '$(GITHUB_DEPLOY_KEY)' > $(KEY_FILE)
 	@git remote rm github-deploy || true
 	git remote add github-deploy $(GITHUB_REPO)
 	-@GIT_SSH_COMMAND="ssh -i $(KEY_FILE)" git fetch github-deploy $(CI_COMMIT_REF_NAME)
@@ -22,7 +22,4 @@ else
 	rm $(KEY_FILE)
 endif
 
-push:: git-push
-pull:: git-pull
-
-.PHONY:: commit tag push git-push git-pull push-github 
+.PHONY:: commit tag git-push git-pull push-github 

.makefiles/k8s.mk

@@ -13,7 +13,7 @@
 KUBE_CA_TEMP=false
 ifndef KUBE_CA_PEM_FILE
 KUBE_CA_PEM_FILE:=$$PWD/.ca.crt
-CREATED:=$(shell echo -e "$(KUBE_CA_BUNDLE)" > $(KUBE_CA_PEM_FILE))
+CREATED:=$(shell printf '%b\n' '$(KUBE_CA_BUNDLE)' > $(KUBE_CA_PEM_FILE))
 endif 
 KUBE_TOKEN?=""
 KUBE_NAMESPACE?=$(NAME)

.makefiles/makefiles.mk

@@ -1,17 +1,15 @@
 makefiles-remote:
-	@git remote add makefiles ssh://git@lab.cluster.gsi.dit.upm.es:2200/docs/templates/makefiles.git 2>/dev/null || true
+	git ls-remote --exit-code  makefiles 2> /dev/null || git remote add makefiles ssh://git@lab.cluster.gsi.dit.upm.es:2200/docs/templates/makefiles.git
 
 makefiles-commit: makefiles-remote
 	git add -f .makefiles
 	git commit -em "Updated makefiles from ${NAME}"
 
 makefiles-push:
+	git fetch makefiles $(NAME)
 	git subtree push --prefix=.makefiles/ makefiles $(NAME)
 
 makefiles-pull: makefiles-remote
 	git subtree pull --prefix=.makefiles/ makefiles master --squash
 
-pull:: makefiles-pull
-push:: makefiles-push
-
-.PHONY:: makefiles-remote makefiles-commit makefiles-push makefiles-pull pull push
+.PHONY:: makefiles-remote makefiles-commit makefiles-push makefiles-pull

.makefiles/python.mk

@@ -1,9 +1,17 @@
-PYVERSIONS ?= 2.7
+PYVERSIONS ?= 3.5
 PYMAIN ?= $(firstword $(PYVERSIONS))
 TARNAME ?= $(NAME)-$(VERSION).tar.gz 
+VERSIONFILE ?= $(NAME)/VERSION
 
 DEVPORT ?= 6000
 
+
+.FORCE:
+
+version: .FORCE
+	@echo $(VERSION) > $(VERSIONFILE)
+	@echo $(VERSION)
+
 yapf: ## Format python code
 	yapf -i -r $(NAME)
 	yapf -i -r tests
@@ -18,9 +26,10 @@ Dockerfile-%: Dockerfile.template  ## Generate a specific dockerfile (e.g. Docke
 quick_build: $(addprefix build-, $(PYMAIN))
 
 build: $(addprefix build-, $(PYVERSIONS)) ## Build all images / python versions
+	docker tag $(IMAGEWTAG)-python$(PYMAIN) $(IMAGEWTAG)
 
 build-%: version Dockerfile-%  ## Build a specific version (e.g. build-2.7)
-	docker build -t '$(IMAGEWTAG)-python$*' --cache-from $(IMAGENAME):python$* -f Dockerfile-$* .;
+	docker build --pull -t '$(IMAGEWTAG)-python$*' -f Dockerfile-$* .;
 
 dev-%: ## Launch a specific development environment using docker (e.g. dev-2.7)
 	@docker start $(NAME)-dev$* || (\
@@ -34,10 +43,10 @@ dev: dev-$(PYMAIN) ## Launch a development environment using docker, using the d
 
 quick_test: test-$(PYMAIN)
 
-test-%: ## Run setup.py from in an isolated container, built from the base image. (e.g. test-2.7)
+test-%: build-% ## Run setup.py from in an isolated container, built from the base image. (e.g. test-2.7)
 # This speeds tests up because the image has most (if not all) of the dependencies already.
 	docker rm $(NAME)-test-$* || true
-	docker create -ti --name $(NAME)-test-$* --entrypoint="" -w /usr/src/app/ $(IMAGENAME):python$* python setup.py test
+	docker create -ti --name $(NAME)-test-$* --entrypoint="" -w /usr/src/app/ $(IMAGEWTAG)-python$* python setup.py test
 	docker cp . $(NAME)-test-$*:/usr/src/app
 	docker start -a $(NAME)-test-$*
 
@@ -67,7 +76,7 @@ pip_upload: pip_test  ## Upload package to pip
 
 push-latest: $(addprefix push-latest-,$(PYVERSIONS)) ## Push the "latest" tag to dockerhub
 	docker tag '$(IMAGEWTAG)-python$(PYMAIN)' '$(IMAGEWTAG)'
-	docker tag '$(IMAGEWTAG)-python$(PYMAIN)' '$(IMAGENAME)'
+	docker tag '$(IMAGEWTAG)-python$(PYMAIN)' '$(IMAGENAME):latest'
 	docker push '$(IMAGENAME):latest'
 	docker push '$(IMAGEWTAG)'
 
@@ -89,4 +98,4 @@ clean:: ## Clean older docker images and containers related to this project and
 	@docker ps -a | grep $(IMAGENAME) | awk '{ split($$2, vers, "-"); if(vers[0] != "${VERSION}"){ print $$1;}}' | xargs docker rm -v 2>/dev/null|| true
 	@docker images | grep $(IMAGENAME) | awk '{ split($$2, vers, "-"); if(vers[0] != "${VERSION}"){ print $$1":"$$2;}}' | xargs docker rmi 2>/dev/null|| true
 
-.PHONY:: yapf dockerfiles Dockerfile-% quick_build build build-% dev-% quick-dev test quick_test push-latest push-latest-% push-% push
+.PHONY:: yapf dockerfiles Dockerfile-% quick_build build build-% dev-% quick-dev test quick_test push-latest push-latest-% push-% push version .FORCE

.travis.yml

@@ -6,7 +6,10 @@ services:
 language: python
 
 env:
-  - PYV=2.7
+  - PYV=3.4
   - PYV=3.5
+  - PYV=3.6
+  - PYV=3.7
+#  - PYV=3.3 # Apt fails in this docker image
 # run nosetests - Tests
 script: make test-$PYV

CHANGELOG.md

@@ -0,0 +1,59 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Fixed
+* Restored hash changing function in `main.js`
+
+## 0.20
+
+### Added
+* Objects can control the keys that will be used in `serialize`/`jsonld`/`as_dict` by specifying a list of keys in `terse_keys`.
+e.g.
+```python
+>>> class MyModel(senpy.models.BaseModel):
+...   _terse_keys = ['visible']
+...   invisible = 5
+...   visible = 1
+...
+>>> m = MyModel(id='testing')
+>>> m.jsonld()
+{'invisible': 5, 'visible': 1, '@id': 'testing'}
+>>> m.jsonld(verbose=False)
+{'visible': 1}
+```
+* Configurable logging format.
+* Added default terse keys for the most common classes (entry, sentiment, emotion...).
+* Flag parameters (boolean) are set to true even when no value is added (e.g. `&verbose` is the same as `&verbose=true`).
+* Plugin and parameter descriptions are now formatted with (showdown)[https://github.com/showdownjs/showdown].
+* The web UI requests extra_parameters from the server. This is useful for pipelines. See #52
+* First batch of semantic tests (using SPARQL)
+* `Plugin.path()` method to get a file path from a relative path (using the senpy data folder)
+
+### Changed
+* `install_deps` now checks what requirements are already met before installing with pip.
+* Help is now provided verbosely by default
+* Other outputs are terse by default. This means some properties are now hidden unless verbose is set.
+* `sentiments` and `emotions` are now `marl:hasOpinion` and `onyx:hasEmotionSet`, respectively.
+* Nicer logging format
+* Context aliases (e.g. `sentiments` and `emotions` properties) have been replaced with the original properties (e.g. `marl:hasOpinion` and `onyx:hasEmotionSet**), to use aliases, pass the `aliases** parameter.
+* Several UI improvements
+  * Dedicated tab to show the list of plugins
+  * URLs in plugin descriptions are shown as links
+  * The format of the response is selected by clicking on a tab instead of selecting from a drop-down
+  * list of examples
+  * Bootstrap v4
+* RandEmotion and RandSentiment are no longer included in the base set of plugins
+* The `--plugin-folder` option can be used more than once, and every folder will be added to the app.
+
+### Deprecated
+### Removed
+* Python 2.7 is no longer test or officially supported
+### Fixed
+* Plugin descriptions are now dedented when they are extracted from the docstring.
+### Security
+

Dockerfile.template

@@ -2,6 +2,10 @@ from python:{{PYVERSION}}
 
 MAINTAINER J. Fernando Sánchez <jf.sanchez@upm.es>
 
+RUN apt-get update && apt-get install -y \
+libblas-dev liblapack-dev liblapacke-dev gfortran \
+ && rm -rf /var/lib/apt/lists/*
+
 RUN mkdir /cache/ /senpy-plugins /data/
 
 VOLUME /data/
@@ -14,9 +18,9 @@ ONBUILD WORKDIR /senpy-plugins/
 
 
 WORKDIR /usr/src/app
-COPY test-requirements.txt requirements.txt /usr/src/app/
-RUN pip install --use-wheel -r test-requirements.txt -r requirements.txt
+COPY test-requirements.txt requirements.txt extra-requirements.txt /usr/src/app/
+RUN pip install --no-cache-dir -r test-requirements.txt -r requirements.txt -r extra-requirements.txt
 COPY . /usr/src/app/
-RUN pip install --no-index --no-deps --editable .
+RUN pip install --no-cache-dir --no-index --no-deps --editable .
 
 ENTRYPOINT ["python", "-m", "senpy", "-f", "/senpy-plugins/", "--host", "0.0.0.0"]

MANIFEST.in

@@ -1,5 +1,6 @@
 include requirements.txt
 include test-requirements.txt
+include extra-requirements.txt
 include README.rst
 include senpy/VERSION
 graft senpy/plugins

Makefile

@@ -5,7 +5,7 @@ IMAGENAME=gsiupm/senpy
 
 # The first version is the main one (used for quick builds)
 # See .makefiles/python.mk for more info
-PYVERSIONS=3.5 2.7
+PYVERSIONS=3.6 3.7
 
 DEVPORT=5000
 

Procfile

@@ -1 +1 @@
-web: python -m senpy --host 0.0.0.0 --port $PORT --default-plugins
+web: python -m senpy --host 0.0.0.0 --port $PORT

README.rst

@@ -1,10 +1,19 @@
 .. image:: img/header.png
    :width: 100%
-   :target: http://demos.gsi.dit.upm.es/senpy
+   :target: http://senpy.gsi.upm.es
 
 .. image:: https://travis-ci.org/gsi-upm/senpy.svg?branch=master
    :target: https://travis-ci.org/gsi-upm/senpy
 
+.. image:: https://lab.gsi.upm.es/senpy/senpy/badges/master/pipeline.svg
+   :target: https://lab.gsi.upm.es/senpy/senpy/commits/master
+
+.. image:: https://lab.gsi.upm.es/senpy/senpy/badges/master/coverage.svg
+   :target: https://lab.gsi.upm.es/senpy/senpy/commits/master
+
+.. image:: https://img.shields.io/pypi/l/requests.svg
+   :target: https://lab.gsi.upm.es/senpy/senpy/
+
 Senpy lets you create sentiment analysis web services easily, fast and using a well known API.
 As a bonus, senpy services use semantic vocabularies (e.g. `NIF <http://persistence.uni-leipzig.org/nlp2rdf/>`_, `Marl <http://www.gsi.dit.upm.es/ontologies/marl>`_, `Onyx <http://www.gsi.dit.upm.es/ontologies/onyx>`_) and formats (turtle, JSON-LD, xml-rdf).
 
@@ -12,7 +21,7 @@ Have you ever wanted to turn your sentiment analysis algorithms into a service?
 With senpy, now you can.
 It provides all the tools so you just have to worry about improving your algorithms:
 
-`See it in action. <http://senpy.cluster.gsi.dit.upm.es/>`_
+`See it in action. <http://senpy.gsi.upm.es/>`_
 
 Installation
 ------------
@@ -38,9 +47,9 @@ If you want to install senpy globally, use sudo instead of the ``--user`` flag.
 
 Docker Image
 ************
-Build the image or use the pre-built one: ``docker run -ti -p 5000:5000 gsiupm/senpy --default-plugins``.
+Build the image or use the pre-built one: ``docker run -ti -p 5000:5000 gsiupm/senpy``.
 
-To add custom plugins, add a volume and tell senpy where to find the plugins: ``docker run -ti -p 5000:5000 -v <PATH OF PLUGINS>:/plugins gsiupm/senpy --default-plugins -f /plugins``
+To add custom plugins, add a volume and tell senpy where to find the plugins: ``docker run -ti -p 5000:5000 -v <PATH OF PLUGINS>:/plugins gsiupm/senpy -f /plugins``
 
 
 Developing
@@ -125,6 +134,16 @@ For more information, check out the `documentation <http://senpy.readthedocs.org
 ------------------------------------------------------------------------------------
 
 
+Python 2.x compatibility
+------------------------
+
+Keeping compatibility between python 2.7 and 3.x is not always easy, especially for a framework that deals both with text and web requests.
+Hence, starting February 2019, this project will no longer make efforts to support python 2.7, which will reach its end of life in 2020.
+Most of the functionality should still work, and the compatibility shims will remain for now, but we cannot make any guarantees at this point.
+Instead, the maintainers will focus their efforts on keeping the codebase compatible across different Python 3.3+ versions, including upcoming ones.
+We apologize for the inconvenience.
+
+
 Acknowledgement
 ---------------
 This development has been partially funded by the European Union through the MixedEmotions Project (project number H2020 655632), as part of the `RIA ICT 15 Big data and Open Data Innovation and take-up` programme.

config.py

@@ -1,4 +0,0 @@
-import os
-
-SERVER_PORT = os.environ.get("SERVER_PORT", 5000)
-DEBUG = os.environ.get("DEBUG", True)

docker-compose.dev.yml

@@ -0,0 +1,10 @@
+version: '3'
+services:
+    senpy:
+        image: "${IMAGENAME-gsiupm/senpy}:${VERSION-latest}"
+        entrypoint: ["/bin/bash"]
+        working_dir: "/senpy-plugins"
+        ports:
+            - 5000:5000
+        volumes:
+            - ".:/usr/src/app/"

docker-compose.test.yml

@@ -0,0 +1,9 @@
+version: '3'
+services:
+    test:
+        image: "${IMAGENAME-gsiupm/senpy}:${VERSION-dev}"
+        entrypoint: ["py.test"]
+        volumes:
+            - ".:/usr/src/app/"
+        command:
+          []

docker-compose.yml

@@ -0,0 +1,11 @@
+version: '3'
+services:
+    senpy:
+        image: "${IMAGENAME-gsiupm/senpy}:${VERSION-dev}"
+        build:
+          context: .
+          dockerfile: Dockerfile${PYVERSION--2.7}
+        ports:
+            - 5001:5000
+        volumes:
+            - "./data:/data"

docs/Makefile

@@ -24,6 +24,7 @@ I18NSPHINXOPTS  = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
 help:
 	@echo "Please use \`make <target>' where <target> is one of"
 	@echo "  html       to make standalone HTML files"
+	@echo "  entr       to watch for changes and continuously make HTML files"
 	@echo "  dirhtml    to make HTML files named index.html in directories"
 	@echo "  singlehtml to make a single large HTML file"
 	@echo "  pickle     to make pickle files"
@@ -49,6 +50,9 @@ help:
 clean:
 	rm -rf $(BUILDDIR)/*
 
+entr:
+	while true; do ag -g rst | entr -d make html; done 
+
 html:
 	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
 	@echo

docs/Quickstart-1minute.ipynb

@@ -0,0 +1,152 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Senpy in 1 minute\n",
+    "\n",
+    "This mini-tutorial only shows how to annotate with a service.\n",
+    "We will use the [demo server](http://senpy.gsi.upm.es), which runs some open source plugins for sentiment and emotion analysis."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Annotating with senpy is as simple as issuing an HTTP request to the API using your favourite tool.\n",
+    "This is just an example using curl:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{\r\n",
+      "  \"@context\": \"http://senpy.gsi.upm.es/api/contexts/YXBpL3NlbnRpbWVudDE0MD8j\",\r\n",
+      "  \"@type\": \"Results\",\r\n",
+      "  \"entries\": [\r\n",
+      "    {\r\n",
+      "      \"@id\": \"prefix:\",\r\n",
+      "      \"@type\": \"Entry\",\r\n",
+      "      \"marl:hasOpinion\": [\r\n",
+      "        {\r\n",
+      "          \"@type\": \"Sentiment\",\r\n",
+      "          \"marl:hasPolarity\": \"marl:Positive\",\r\n",
+      "          \"prov:wasGeneratedBy\": \"prefix:Analysis_1554389334.6431913\"\r\n",
+      "        }\r\n",
+      "      ],\r\n",
+      "      \"nif:isString\": \"Senpy is awesome\",\r\n",
+      "      \"onyx:hasEmotionSet\": []\r\n",
+      "    }\r\n",
+      "  ]\r\n",
+      "}"
+     ]
+    }
+   ],
+   "source": [
+    "!curl \"http://senpy.gsi.upm.es/api/sentiment140\" --data-urlencode \"input=Senpy is awesome\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Congratulations**, you've used your first senpy service!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here is the equivalent using the `requests` library:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{\n",
+      "  \"@context\": \"http://senpy.gsi.upm.es/api/contexts/YXBpL3NlbnRpbWVudDE0MD9pbnB1dD1TZW5weStpcythd2Vzb21lIw%3D%3D\",\n",
+      "  \"@type\": \"Results\",\n",
+      "  \"entries\": [\n",
+      "    {\n",
+      "      \"@id\": \"prefix:\",\n",
+      "      \"@type\": \"Entry\",\n",
+      "      \"marl:hasOpinion\": [\n",
+      "        {\n",
+      "          \"@type\": \"Sentiment\",\n",
+      "          \"marl:hasPolarity\": \"marl:Positive\",\n",
+      "          \"prov:wasGeneratedBy\": \"prefix:Analysis_1554389335.9803226\"\n",
+      "        }\n",
+      "      ],\n",
+      "      \"nif:isString\": \"Senpy is awesome\",\n",
+      "      \"onyx:hasEmotionSet\": []\n",
+      "    }\n",
+      "  ]\n",
+      "}\n"
+     ]
+    }
+   ],
+   "source": [
+    "import requests\n",
+    "res = requests.get('http://senpy.gsi.upm.es/api/sentiment140',\n",
+    "                   params={\"input\": \"Senpy is awesome\",})\n",
+    "print(res.text)"
+   ]
+  }
+ ],
+ "metadata": {
+  "anaconda-cloud": {},
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.3"
+  },
+  "toc": {
+   "colors": {
+    "hover_highlight": "#DAA520",
+    "running_highlight": "#FF0000",
+    "selected_highlight": "#FFD700"
+   },
+   "moveMenuLeft": true,
+   "nav_menu": {
+    "height": "68px",
+    "width": "252px"
+   },
+   "navigate_menu": true,
+   "number_sections": true,
+   "sideBar": true,
+   "threshold": 4,
+   "toc_cell": false,
+   "toc_section_display": "block",
+   "toc_window_display": false
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}

docs/Quickstart.ipynb

@@ -0,0 +1,81 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Quickstart\n",
+    "\n",
+    "This short tutorial will teach you how to consume senpy services for several tasks, and how to take advantage of the features of the framework.\n",
+    "\n",
+    "In particular, it covers:\n",
+    "\n",
+    "* Annotating text with sentiment and emotion using interoperable services\n",
+    "* Switching to different services (service interoperability)\n",
+    "* Getting results in different formats (Turtle, XML, text...)\n",
+    "* Asking for specific emotion models (automatic model conversion)\n",
+    "* Listing available services in an endpoint\n",
+    "* Calling multiple services in the same request (Pipelines)\n",
+    "\n",
+    "These topics are split into two separate tutorials.\n",
+    "\n",
+    "Reading all the sections is not necessary, although it is encouraged in order to get a glimpse of all the features."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "nbsphinx-toctree": {
+     "maxdepth": 2
+    }
+   },
+   "source": [
+    "* [Senpy in 1 minute](./Quickstart-1minute.ipynb) shows how to query the API.\n",
+    "* [Senpy in 10 minutes](./Quickstart-10minutes.ipynb) introduces basic sentiment and emotion analysis.\n",
+    "* [Senpy in 30 minutes](./Quickstart-30minutes.ipynb) builds on the previous and adds more advanced functionalities, such as emotion conversion, field selection and pipelines."
+   ]
+  }
+ ],
+ "metadata": {
+  "anaconda-cloud": {},
+  "celltoolbar": "Edit Metadata",
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.3"
+  },
+  "toc": {
+   "colors": {
+    "hover_highlight": "#DAA520",
+    "running_highlight": "#FF0000",
+    "selected_highlight": "#FFD700"
+   },
+   "moveMenuLeft": true,
+   "nav_menu": {
+    "height": "68px",
+    "width": "252px"
+   },
+   "navigate_menu": true,
+   "number_sections": true,
+   "sideBar": true,
+   "threshold": 4,
+   "toc_cell": false,
+   "toc_section_display": "block",
+   "toc_window_display": false
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}

docs/SenpyClientUse.ipynb

@@ -1,317 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2017-04-10T17:05:31.465571Z",
-     "start_time": "2017-04-10T19:05:31.458282+02:00"
-    },
-    "deletable": true,
-    "editable": true
-   },
-   "source": [
-    "# Client"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "collapsed": true,
-    "deletable": true,
-    "editable": true
-   },
-   "source": [
-    "The built-in senpy client allows you to query any Senpy endpoint. We will illustrate how to use it with the public demo endpoint, and then show you how to spin up your own endpoint using docker."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "deletable": true,
-    "editable": true
-   },
-   "source": [
-    "Demo Endpoint\n",
-    "-------------"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "deletable": true,
-    "editable": true
-   },
-   "source": [
-    "To start using senpy, simply create a new Client and point it to your endpoint. In this case, the latest version of Senpy at GSI."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2017-04-10T17:29:12.827640Z",
-     "start_time": "2017-04-10T19:29:12.818617+02:00"
-    },
-    "collapsed": false,
-    "deletable": true,
-    "editable": true
-   },
-   "outputs": [],
-   "source": [
-    "from senpy.client import Client\n",
-    "\n",
-    "c = Client('http://latest.senpy.cluster.gsi.dit.upm.es/api')\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "deletable": true,
-    "editable": true
-   },
-   "source": [
-    "Now, let's use that client analyse some queries:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2017-04-10T17:29:14.011657Z",
-     "start_time": "2017-04-10T19:29:13.701808+02:00"
-    },
-    "collapsed": false,
-    "deletable": true,
-    "editable": true
-   },
-   "outputs": [],
-   "source": [
-    "r = c.analyse('I like sugar!!', algorithm='sentiment140')\n",
-    "r"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2017-04-10T17:08:19.616754Z",
-     "start_time": "2017-04-10T19:08:19.610767+02:00"
-    },
-    "deletable": true,
-    "editable": true
-   },
-   "source": [
-    "As you can see, that gave us the full JSON result. A more concise way to print it would be:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2017-04-10T17:29:14.854213Z",
-     "start_time": "2017-04-10T19:29:14.842068+02:00"
-    },
-    "collapsed": false,
-    "deletable": true,
-    "editable": true
-   },
-   "outputs": [],
-   "source": [
-    "for entry in r.entries:\n",
-    "      print('{} -> {}'.format(entry['text'], entry['sentiments'][0]['marl:hasPolarity']))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "deletable": true,
-    "editable": true
-   },
-   "source": [
-    "We can also obtain a list of available plugins with the client:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2017-04-10T17:29:16.245198Z",
-     "start_time": "2017-04-10T19:29:16.056545+02:00"
-    },
-    "collapsed": false,
-    "deletable": true,
-    "editable": true
-   },
-   "outputs": [],
-   "source": [
-    "c.plugins()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "deletable": true,
-    "editable": true
-   },
-   "source": [
-    "Or, more concisely:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2017-04-10T17:29:17.663275Z",
-     "start_time": "2017-04-10T19:29:17.484623+02:00"
-    },
-    "collapsed": false,
-    "deletable": true,
-    "editable": true
-   },
-   "outputs": [],
-   "source": [
-    "c.plugins().keys()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "deletable": true,
-    "editable": true
-   },
-   "source": [
-    "Local Endpoint\n",
-    "--------------"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "deletable": true,
-    "editable": true
-   },
-   "source": [
-    "To run your own instance of senpy, just create a docker container with the latest Senpy image. Using `--default-plugins` you will get some extra plugins to start playing with the API."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2017-04-10T17:29:20.637539Z",
-     "start_time": "2017-04-10T19:29:19.938322+02:00"
-    },
-    "collapsed": false,
-    "deletable": true,
-    "editable": true
-   },
-   "outputs": [],
-   "source": [
-    "!docker run -ti --name 'SenpyEndpoint' -d -p 6000:5000 gsiupm/senpy:0.8.6 --host 0.0.0.0 --default-plugins"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "deletable": true,
-    "editable": true
-   },
-   "source": [
-    "To use this endpoint:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2017-04-10T17:29:21.263976Z",
-     "start_time": "2017-04-10T19:29:21.260595+02:00"
-    },
-    "collapsed": false,
-    "deletable": true,
-    "editable": true
-   },
-   "outputs": [],
-   "source": [
-    "c_local = Client('http://127.0.0.1:6000/api')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "deletable": true,
-    "editable": true
-   },
-   "source": [
-    "That's all! After you are done with your analysis, stop the docker container:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2017-04-10T17:29:33.226686Z",
-     "start_time": "2017-04-10T19:29:22.392121+02:00"
-    },
-    "collapsed": false,
-    "deletable": true,
-    "editable": true
-   },
-   "outputs": [],
-   "source": [
-    "!docker stop SenpyEndpoint\n",
-    "!docker rm SenpyEndpoint"
-   ]
-  }
- ],
- "metadata": {
-  "anaconda-cloud": {},
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.6.0"
-  },
-  "toc": {
-   "colors": {
-    "hover_highlight": "#DAA520",
-    "running_highlight": "#FF0000",
-    "selected_highlight": "#FFD700"
-   },
-   "moveMenuLeft": true,
-   "nav_menu": {
-    "height": "68px",
-    "width": "252px"
-   },
-   "navigate_menu": true,
-   "number_sections": true,
-   "sideBar": true,
-   "threshold": 4,
-   "toc_cell": false,
-   "toc_section_display": "block",
-   "toc_window_display": false
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 1
-}

docs/about.rst

@@ -1,11 +0,0 @@
-About
---------
-
-If you use Senpy in your research, please cite `Senpy: A Pragmatic Linked Sentiment Analysis Framework <http://gsi.dit.upm.es/index.php/es/investigacion/publicaciones?view=publication&task=show&id=417>`__ (`BibTex <http://gsi.dit.upm.es/index.php/es/investigacion/publicaciones?controller=publications&task=export&format=bibtex&id=417>`__):
-
-.. code-block:: text
-
-	Sánchez-Rada, J. F., Iglesias, C. A., Corcuera, I., & Araque, Ó. (2016, October).
-	Senpy: A Pragmatic Linked Sentiment Analysis Framework.
-	In Data Science and Advanced Analytics (DSAA),
-	2016 IEEE International Conference on (pp. 735-742). IEEE.

docs/advanced.rst

@@ -0,0 +1,10 @@
+Advanced usage
+--------------
+
+.. toctree::
+    :maxdepth: 1
+
+    server-cli
+    conversion
+    commandline
+    development

docs/api.rst

@@ -25,7 +25,7 @@ NIF API
         "@context":"http://127.0.0.1/api/contexts/Results.jsonld",
         "@id":"_:Results_11241245.22",
         "@type":"results"
-        "analysis": [
+        "activities": [
           "plugins/sentiment-140_0.1" 
         ],
         "entries": [
@@ -73,7 +73,7 @@ NIF API
 .. http:get:: /api/plugins
 
    Returns a list of installed plugins. 
-   **Example request**:
+   **Example request and response**:
 
    .. sourcecode:: http
 
@@ -82,10 +82,6 @@ NIF API
       Accept: application/json, text/javascript
 
 
-   **Example response**:
-
-   .. sourcecode:: http
-
       {
         "@id": "plugins/sentiment-140_0.1", 
         "@type": "sentimentPlugin", 
@@ -143,19 +139,14 @@ NIF API
 .. http:get:: /api/plugins/<pluginname>
 
    Returns the information of a specific plugin.
-   **Example request**:
+   **Example request and response**:
 
    .. sourcecode:: http
 
-      GET /api/plugins/rand/ HTTP/1.1
+      GET /api/plugins/sentiment-random/ HTTP/1.1
       Host: localhost
       Accept: application/json, text/javascript
 
-
-   **Example response**:
-
-   .. sourcecode:: http
-
       {
         "@context": "http://127.0.0.1/api/contexts/ExamplePlugin.jsonld", 
         "@id": "plugins/ExamplePlugin_0.1", 

docs/apischema.rst

@@ -1,5 +1,6 @@
-API and Examples
-################
+API and vocabularies
+####################
+
 .. toctree::
 
    vocabularies.rst

docs/bad-examples/results/example-analysis-as-id-FAIL.json

@@ -2,7 +2,7 @@
   "@context": "http://mixedemotions-project.eu/ns/context.jsonld",
   "@id": "me:Result1",
   "@type": "results",
-  "analysis": [
+  "activities": [
     "me:SAnalysis1",
     "me:SgAnalysis1",
     "me:EmotionAnalysis1",

docs/bad-examples/results/example-basic-FAIL.json

@@ -2,17 +2,13 @@
   "@context": "http://mixedemotions-project.eu/ns/context.jsonld",
   "@id": "http://example.com#NIFExample",
   "@type": "results",
-  "analysis": [
+  "activities": [
   ],
   "entries": [
     {
-      "@type": [
-        "nif:RFC5147String",
-        "nif:Context"
-      ],
       "nif:beginIndex": 0,
       "nif:endIndex": 40,
-      "nif:isString": "My favourite actress is Natalie Portman"
+      "text": "An entry should have a nif:isString key"
     }
   ]
 }

docs/commandline.rst

@@ -1,7 +1,8 @@
 Command line
 ============
 
-This video shows how to analyse text directly on the command line using the senpy tool.
+Although the main use of senpy is to publish services, the tool can also be used locally to analyze text in the command line.
+This is a short video demonstration:
 
 .. image:: https://asciinema.org/a/9uwef1ghkjk062cw2t4mhzpyk.png
    :width: 100%

docs/conf.py

@@ -38,6 +38,8 @@ extensions = [
     'sphinxcontrib.httpdomain',
     'sphinx.ext.coverage',
     'sphinx.ext.autosectionlabel',
+    'nbsphinx',
+    'sphinx.ext.mathjax',
 ]
 
 # Add any paths that contain templates here, relative to this directory.
@@ -54,7 +56,7 @@ master_doc = 'index'
 
 # General information about the project.
 project = u'Senpy'
-copyright = u'2016, J. Fernando Sánchez'
+copyright = u'2019, J. Fernando Sánchez'
 description = u'A framework for sentiment and emotion analysis services'
 
 # The version info for the project you're documenting, acts as replacement for
@@ -79,7 +81,9 @@ language = None
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
-exclude_patterns = ['_build']
+exclude_patterns = ['_build', '**.ipynb_checkpoints']
+
+
 
 # The reST default role (used for this markup: `text`) to use for all
 # documents.
@@ -286,3 +290,13 @@ texinfo_documents = [
 
 # If true, do not generate a @detailmenu in the "Top" node's menu.
 #texinfo_no_detailmenu = False
+
+nbsphinx_prolog = """
+.. note:: This page has been auto-generated from a Jupyter notebook using nbsphinx_.
+
+    The original source is available at: https://github.com/gsi-upm/senpy/tree/master/docs//{{ env.doc2path(env.docname, base=None) }}
+
+    .. _nbsphinx: https://nbsphinx.readthedocs.io/
+
+----
+"""

docs/conversion.rst

@@ -7,9 +7,9 @@ Senpy includes experimental support for emotion/sentiment conversion plugins.
 Use
 ===
 
-Consider the original query: http://127.0.0.1:5000/api/?i=hello&algo=emoRand
+Consider the original query: http://127.0.0.1:5000/api/?i=hello&algo=emotion-random
 
-The requested plugin (emoRand) returns emotions using Ekman's model (or big6 in EmotionML):
+The requested plugin (emotion-random) returns emotions using Ekman's model (or big6 in EmotionML):
 
 .. code:: json
 
@@ -21,14 +21,14 @@ The requested plugin (emoRand) returns emotions using Ekman's model (or big6 in
                 "@type": "emotion",
                 "onyx:hasEmotionCategory": "emoml:big6anger"
             },
-            "prov:wasGeneratedBy": "plugins/emoRand_0.1"
+            "prov:wasGeneratedBy": "plugins/emotion-random_0.1"
           }
 
           
 
 To get these emotions in VAD space (FSRE dimensions in EmotionML), we'd do this:
 
-http://127.0.0.1:5000/api/?i=hello&algo=emoRand&emotionModel=emoml:fsre-dimensions
+http://127.0.0.1:5000/api/?i=hello&algo=emotion-random&emotionModel=emoml:fsre-dimensions
 
 This call, provided there is a valid conversion plugin from Ekman's to VAD, would return something like this:
 
@@ -42,7 +42,7 @@ This call, provided there is a valid conversion plugin from Ekman's to VAD, woul
                 "@type": "emotion",
                 "onyx:hasEmotionCategory": "emoml:big6anger"
                 },
-            "prov:wasGeneratedBy": "plugins/emoRand_0.1"
+            "prov:wasGeneratedBy": "plugins/emotion-random.1"
           }, {
             "@type": "emotionSet",
             "onyx:hasEmotion": {
@@ -69,7 +69,7 @@ It is also possible to get the original emotion nested within the new converted
                 "@type": "emotion",
                 "onyx:hasEmotionCategory": "emoml:big6anger"
                 },
-            "prov:wasGeneratedBy": "plugins/emoRand_0.1"
+            "prov:wasGeneratedBy": "plugins/emotion-random.1"
             "onyx:wasDerivedFrom": {
                 "@type": "emotionSet",
                 "onyx:hasEmotion": {

docs/demo.rst

@@ -1,16 +1,13 @@
 Demo
 ----
 
-There is a demo available on http://senpy.cluster.gsi.dit.upm.es/, where you can test a serie of different plugins.
+There is a demo available on http://senpy.gsi.upm.es/, where you can test a live instance of Senpy, with several open source plugins.
 You can use the playground (a web interface) or make HTTP requests to the service API.
 
-.. image:: senpy-playground.png
-  :height: 400px
+.. image:: playground-0.20.png
+  :target: http://senpy.gsi.upm.es
   :width: 800px
-  :scale: 100 %
   :align: center
 
-Plugins Demo
-============
 
-The source code and description of the plugins used in the demo is available here: https://lab.cluster.gsi.dit.upm.es/senpy/senpy-plugins-community/.
+The source code and description of the plugins used in the demo are available here: https://github.com/gsi-upm/senpy-plugins-community/.

docs/development.rst

@@ -0,0 +1,27 @@
+Developing new services
+-----------------------
+
+Developing web services can be hard.
+To illustrate it, the figure below summarizes the typical features in a text analysis service.
+
+.. image:: senpy-framework.png
+  :width: 60%
+  :align: center
+
+Senpy implements all the common blocks, so developers can focus on what really matters: great analysis algorithms that solve real problems.
+Among other things, Senpy takes care of these tasks:
+
+  * Interfacing with the user: parameter validation, error handling.
+  * Formatting: JSON-LD, Turtle/n-triples input and output, or simple text input
+  * Linked Data: senpy results are semantically annotated, using a series of well established vocabularies, and sane default URIs.
+  * User interface: a web UI where users can explore your service and test different settings
+  * A client to interact with the service. Currently only available in Python.
+
+You only need to provide the algorithm to turn a piece of text into an annotation
+Sharing your sentiment analysis with the world has never been easier!
+
+.. toctree::
+    :maxdepth: 1
+
+    plugins-quickstart
+    plugins-faq

docs/examples.rst

@@ -1,5 +1,6 @@
 Examples
-------
+--------
+
 All the examples in this page use the :download:`the main schema <_static/schemas/definitions.json>`.
 
 Simple NIF annotation
@@ -17,6 +18,7 @@ Sentiment Analysis
 .....................
 Description
 ,,,,,,,,,,,
+
 This annotation corresponds to the sentiment analysis of an input. The example shows the sentiment represented according to Marl format.
 The sentiments detected are contained in the Sentiments array with their related part of the text.
 

docs/examples/results/example-analysis-as-id.json

@@ -2,11 +2,22 @@
   "@context": "http://mixedemotions-project.eu/ns/context.jsonld",
   "@id": "me:Result1",
   "@type": "results",
-  "analysis": [
-    "me:SAnalysis1",
-    "me:SgAnalysis1",
-    "me:EmotionAnalysis1",
-    "me:NER1"
+  "activities": [
+      {
+          "@id": "_:SAnalysis1_Activity",
+          "@type": "marl:SentimentAnalysis",
+          "prov:wasAssociatedWith": "me:SAnalysis1"
+      },
+      {
+          "@id": "_:EmotionAnalysis1_Activity",
+          "@type": "onyx:EmotionAnalysis",
+          "prov:wasAssociatedWith": "me:EmotionAnalysis1"
+      },
+      {
+          "@id": "_:NER1_Activity",
+          "@type": "me:NER",
+          "prov:wasAssociatedWith": "me:NER1"
+      }
   ],
   "entries": [
     {
@@ -23,7 +34,7 @@
           "nif:endIndex": 13,
           "nif:anchorOf": "Microsoft",
           "me:references": "http://dbpedia.org/page/Microsoft",
-          "prov:wasGeneratedBy": "me:NER1"
+          "prov:wasGeneratedBy": "_:NER1_Activity"
         },
         {
           "@id": "http://micro.blog/status1#char=25,37",
@@ -31,7 +42,7 @@
           "nif:endIndex": 37,
           "nif:anchorOf": "Windows Phone",
           "me:references": "http://dbpedia.org/page/Windows_Phone",
-          "prov:wasGeneratedBy": "me:NER1"
+          "prov:wasGeneratedBy": "_:NER1_Activity"
         }
       ],
       "suggestions": [
@@ -40,7 +51,7 @@
           "nif:beginIndex": 16,
           "nif:endIndex": 77,
           "nif:anchorOf": "put your Windows Phone on your newest #open technology program",
-          "prov:wasGeneratedBy": "me:SgAnalysis1"
+          "prov:wasGeneratedBy": "_:SgAnalysis1_Activity"
         }
       ],
       "sentiments": [
@@ -51,14 +62,14 @@
           "nif:anchorOf": "You'll be awesome.",
           "marl:hasPolarity": "marl:Positive",
           "marl:polarityValue": 0.9,
-          "prov:wasGeneratedBy": "me:SAnalysis1"
+          "prov:wasGeneratedBy": "_:SgAnalysis1_Activity"
         }
       ],
       "emotions": [
         {
           "@id": "http://micro.blog/status1#char=0,109",
           "nif:anchorOf": "Dear Microsoft, put your Windows Phone on your newest #open technology program. You'll be awesome. #opensource",
-          "prov:wasGeneratedBy": "me:EAnalysis1",
+          "prov:wasGeneratedBy": "_:EmotionAnalysis1_Activity",
           "onyx:hasEmotion": [
             {
               "onyx:hasEmotionCategory": "wna:liking"

docs/examples/results/example-analysis-mixed-ids.json

@@ -1,78 +0,0 @@
-{
-  "@context": "http://mixedemotions-project.eu/ns/context.jsonld",
-  "@id": "me:Result1",
-  "@type": "results",
-  "analysis": [
-    "me:SAnalysis1",
-    "me:SgAnalysis1",
-    "me:EmotionAnalysis1",
-    "me:NER1",
-    {
-    "@type": "analysis",
-    "@id": "anonymous"
-    }
-  ],
-  "entries": [
-    {
-      "@id": "http://micro.blog/status1",
-      "@type": [
-        "nif:RFC5147String",
-        "nif:Context"
-      ],
-      "nif:isString": "Dear Microsoft, put your Windows Phone on your newest #open technology program. You'll be awesome. #opensource",
-      "entities": [
-        {
-          "@id": "http://micro.blog/status1#char=5,13",
-          "nif:beginIndex": 5,
-          "nif:endIndex": 13,
-          "nif:anchorOf": "Microsoft",
-          "me:references": "http://dbpedia.org/page/Microsoft",
-          "prov:wasGeneratedBy": "me:NER1"
-        },
-        {
-          "@id": "http://micro.blog/status1#char=25,37",
-          "nif:beginIndex": 25,
-          "nif:endIndex": 37,
-          "nif:anchorOf": "Windows Phone",
-          "me:references": "http://dbpedia.org/page/Windows_Phone",
-          "prov:wasGeneratedBy": "me:NER1"
-        }
-      ],
-      "suggestions": [
-        {
-          "@id": "http://micro.blog/status1#char=16,77",
-          "nif:beginIndex": 16,
-          "nif:endIndex": 77,
-          "nif:anchorOf": "put your Windows Phone on your newest #open technology program",
-          "prov:wasGeneratedBy": "me:SgAnalysis1"
-        }
-      ],
-      "sentiments": [
-        {
-          "@id": "http://micro.blog/status1#char=80,97",
-          "nif:beginIndex": 80,
-          "nif:endIndex": 97,
-          "nif:anchorOf": "You'll be awesome.",
-          "marl:hasPolarity": "marl:Positive",
-          "marl:polarityValue": 0.9,
-          "prov:wasGeneratedBy": "me:SAnalysis1"
-        }
-      ],
-      "emotions": [
-        {
-          "@id": "http://micro.blog/status1#char=0,109",
-          "nif:anchorOf": "Dear Microsoft, put your Windows Phone on your newest #open technology program. You'll be awesome. #opensource",
-          "prov:wasGeneratedBy": "me:EAnalysis1",
-          "onyx:hasEmotion": [
-            {
-              "onyx:hasEmotionCategory": "wna:liking"
-            },
-            {
-              "onyx:hasEmotionCategory": "wna:excitement"
-            }
-          ]
-        }
-      ]
-    }
-  ]
-}

docs/examples/results/example-basic.json

@@ -1,19 +1,18 @@
 {
-  "@context": "http://mixedemotions-project.eu/ns/context.jsonld",
-  "@id": "http://example.com#NIFExample",
-  "@type": "results",
-  "analysis": [
-  ],
-  "entries": [
-    {
-      "@id": "http://example.org#char=0,40",
-      "@type": [
-        "nif:RFC5147String",
-        "nif:Context"
-      ],
-      "nif:beginIndex": 0,
-      "nif:endIndex": 40,
-      "nif:isString": "My favourite actress is Natalie Portman"
-    }
-  ]
+    "@context": "http://mixedemotions-project.eu/ns/context.jsonld",
+    "@id": "me:Result1",
+    "@type": "results",
+    "activities": [ ],
+    "entries": [
+        {
+            "@id": "http://example.org#char=0,40",
+            "@type": [
+                "nif:RFC5147String",
+                "nif:Context"
+            ],
+            "nif:beginIndex": 0,
+            "nif:endIndex": 40,
+            "nif:isString": "My favourite actress is Natalie Portman"
+        }
+    ]
 }

docs/examples/results/example-complete.json

@@ -1,88 +1,100 @@
 {
-  "@context": "http://mixedemotions-project.eu/ns/context.jsonld",
-  "@id": "me:Result1",
-  "@type": "results",
-  "analysis": [
-    {
-      "@id": "me:SAnalysis1",
-      "@type": "marl:SentimentAnalysis",
-      "marl:maxPolarityValue": 1,
-      "marl:minPolarityValue": 0
-    },
-    {
-      "@id": "me:SgAnalysis1",
-      "@type": "me:SuggestionAnalysis"
-    },
-    {
-      "@id": "me:EmotionAnalysis1",
-      "@type": "me:EmotionAnalysis"
-    },
-    {
-      "@id": "me:NER1",
-      "@type": "me:NER"
-    }
-  ],
-  "entries": [
-    {
-      "@id": "http://micro.blog/status1",
-      "@type": [
-        "nif:RFC5147String",
-        "nif:Context"
-      ],
-      "nif:isString": "Dear Microsoft, put your Windows Phone on your newest #open technology program. You'll be awesome. #opensource",
-      "entities": [
+    "@context": "http://mixedemotions-project.eu/ns/context.jsonld",
+    "@id": "me:Result1",
+    "@type": "results",
+    "activities": [
         {
-          "@id": "http://micro.blog/status1#char=5,13",
-          "nif:beginIndex": 5,
-          "nif:endIndex": 13,
-          "nif:anchorOf": "Microsoft",
-          "me:references": "http://dbpedia.org/page/Microsoft",
-          "prov:wasGeneratedBy": "me:NER1"
+            "@id": "_:SAnalysis1_Activity",
+            "@type": "marl:SentimentAnalysis",
+            "prov:wasAssociatedWith": "me:SentimentAnalysis",
+            "prov:used": [
+                {
+                    "name": "marl:maxPolarityValue",
+                    "prov:value": "1"
+                },
+                {
+                    "name": "marl:minPolarityValue",
+                    "prov:value": "0"
+                }
+            ]
         },
         {
-          "@id": "http://micro.blog/status1#char=25,37",
-          "nif:beginIndex": 25,
-          "nif:endIndex": 37,
-          "nif:anchorOf": "Windows Phone",
-          "me:references": "http://dbpedia.org/page/Windows_Phone",
-          "prov:wasGeneratedBy": "me:NER1"
-        }
-      ],
-      "suggestions": [
+            "@id": "_:SgAnalysis1_Activity",
+            "prov:wasAssociatedWith": "me:SgAnalysis1",
+            "@type": "me:SuggestionAnalysis"
+        },
         {
-          "@id": "http://micro.blog/status1#char=16,77",
-          "nif:beginIndex": 16,
-          "nif:endIndex": 77,
-          "nif:anchorOf": "put your Windows Phone on your newest #open technology program",
-          "prov:wasGeneratedBy": "me:SgAnalysis1"
-        }
-      ],
-      "sentiments": [
+            "@id": "_:EmotionAnalysis1_Activity",
+            "@type": "me:EmotionAnalysis",
+            "prov:wasAssociatedWith": "me:EmotionAnalysis1"
+        },
         {
-          "@id": "http://micro.blog/status1#char=80,97",
-          "nif:beginIndex": 80,
-          "nif:endIndex": 97,
-          "nif:anchorOf": "You'll be awesome.",
-          "marl:hasPolarity": "marl:Positive",
-          "marl:polarityValue": 0.9,
-          "prov:wasGeneratedBy": "me:SAnalysis1"
+            "@id": "_:NER1_Activity",
+            "@type": "me:NER",
+            "prov:wasAssociatedWith": "me:EmotionNER1"
         }
-      ],
-      "emotions": [
+    ],
+    "entries": [
         {
-          "@id": "http://micro.blog/status1#char=0,109",
-          "nif:anchorOf": "Dear Microsoft, put your Windows Phone on your newest #open technology program. You'll be awesome. #opensource",
-          "prov:wasGeneratedBy": "me:EAnalysis1",
-          "onyx:hasEmotion": [
-            {
-              "onyx:hasEmotionCategory": "wna:liking"
-            },
-            {
-              "onyx:hasEmotionCategory": "wna:excitement"
-            }
-          ]
+            "@id": "http://micro.blog/status1",
+            "@type": [
+                "nif:RFC5147String",
+                "nif:Context"
+            ],
+            "nif:isString": "Dear Microsoft, put your Windows Phone on your newest #open technology program. You'll be awesome. #opensource",
+            "entities": [
+                {
+                    "@id": "http://micro.blog/status1#char=5,13",
+                    "nif:beginIndex": 5,
+                    "nif:endIndex": 13,
+                    "nif:anchorOf": "Microsoft",
+                    "me:references": "http://dbpedia.org/page/Microsoft",
+                    "prov:wasGeneratedBy": "me:NER1"
+                },
+                {
+                    "@id": "http://micro.blog/status1#char=25,37",
+                    "nif:beginIndex": 25,
+                    "nif:endIndex": 37,
+                    "nif:anchorOf": "Windows Phone",
+                    "me:references": "http://dbpedia.org/page/Windows_Phone",
+                    "prov:wasGeneratedBy": "me:NER1"
+                }
+            ],
+            "suggestions": [
+                {
+                    "@id": "http://micro.blog/status1#char=16,77",
+                    "nif:beginIndex": 16,
+                    "nif:endIndex": 77,
+                    "nif:anchorOf": "put your Windows Phone on your newest #open technology program",
+                    "prov:wasGeneratedBy": "me:SgAnalysis1"
+                }
+            ],
+            "sentiments": [
+                {
+                    "@id": "http://micro.blog/status1#char=80,97",
+                    "nif:beginIndex": 80,
+                    "nif:endIndex": 97,
+                    "nif:anchorOf": "You'll be awesome.",
+                    "marl:hasPolarity": "marl:Positive",
+                    "marl:polarityValue": 0.9,
+                    "prov:wasGeneratedBy": "me:SAnalysis1"
+                }
+            ],
+            "emotions": [
+                {
+                    "@id": "http://micro.blog/status1#char=0,109",
+                    "nif:anchorOf": "Dear Microsoft, put your Windows Phone on your newest #open technology program. You'll be awesome. #opensource",
+                    "prov:wasGeneratedBy": "me:EAnalysis1",
+                    "onyx:hasEmotion": [
+                        {
+                            "onyx:hasEmotionCategory": "wna:liking"
+                        },
+                        {
+                            "onyx:hasEmotionCategory": "wna:excitement"
+                        }
+                    ]
+                }
+            ]
         }
-      ]
-    }
-  ]
+    ]
 }

docs/examples/results/example-emotion.json

@@ -2,10 +2,11 @@
   "@context": "http://mixedemotions-project.eu/ns/context.jsonld",
   "@id": "me:Result1",
   "@type": "results",
-  "analysis": [
+  "activities": [
     {
-      "@id": "me:EmotionAnalysis1",
-      "@type": "onyx:EmotionAnalysis"
+      "@id": "me:EmotionAnalysis1_Activity",
+      "@type": "me:EmotionAnalysis1",
+      "prov:wasAssociatedWith": "me:EmotionAnalysis1"
     }
   ],
   "entries": [
@@ -26,7 +27,7 @@
         {
           "@id": "http://micro.blog/status1#char=0,109",
           "nif:anchorOf": "Dear Microsoft, put your Windows Phone on your newest #open technology program. You'll be awesome. #opensource",
-          "prov:wasGeneratedBy": "me:EmotionAnalysis1",
+          "prov:wasGeneratedBy": "_:EmotionAnalysis1_Activity",
           "onyx:hasEmotion": [
             {
               "onyx:hasEmotionCategory": "wna:liking"

docs/examples/results/example-ner.json

@@ -2,10 +2,11 @@
   "@context": "http://mixedemotions-project.eu/ns/context.jsonld",
   "@id": "me:Result1",
   "@type": "results",
-  "analysis": [
+  "activities": [
     {
-      "@id": "me:NER1",
-      "@type": "me:NERAnalysis"
+      "@id": "_:NER1_Activity",
+      "@type": "me:NERAnalysis",
+      "prov:wasAssociatedWith": "me:NER1"
     }
   ],
   "entries": [

docs/examples/results/example-pad.json

@@ -7,11 +7,17 @@
   ],
   "@id": "me:Result1",
   "@type": "results",
-  "analysis": [
+  "activities": [
     {
-      "@id": "me:HesamsAnalysis",
+      "@id": "me:HesamsAnalysis_Activity",
       "@type": "onyx:EmotionAnalysis",
-      "onyx:usesEmotionModel": "emovoc:pad-dimensions"
+      "prov:wasAssociatedWith": "me:HesamsAnalysis",
+      "prov:used": [
+        {
+          "name": "emotion-model",
+          "prov:value": "emovoc:pad-dimensions"
+        }
+      ]
     }
   ],
   "entries": [
@@ -32,7 +38,7 @@
         {
           "@id": "Entry1#char=0,21",
           "nif:anchorOf": "This is a test string",
-          "prov:wasGeneratedBy": "me:HesamAnalysis",
+          "prov:wasGeneratedBy": "_:HesamAnalysis_Activity",
           "onyx:hasEmotion": [
             {
                 "emovoc:pleasure": 0.5,

docs/examples/results/example-sentiment.json

@@ -2,12 +2,11 @@
   "@context": "http://mixedemotions-project.eu/ns/context.jsonld",
   "@id": "me:Result1",
   "@type": "results",
-  "analysis": [
+  "activities": [
     {
-      "@id": "me:SAnalysis1",
+      "@id": "_:SAnalysis1_Activity",
       "@type": "marl:SentimentAnalysis",
-      "marl:maxPolarityValue": 1,
-      "marl:minPolarityValue": 0
+      "prov:wasAssociatedWith": "me:SAnalysis1"
     }
   ],
   "entries": [
@@ -30,7 +29,7 @@
           "nif:anchorOf": "You'll be awesome.",
           "marl:hasPolarity": "marl:Positive",
           "marl:polarityValue": 0.9,
-          "prov:wasGeneratedBy": "me:SAnalysis1"
+          "prov:wasGeneratedBy": "_:SAnalysis1_Activity"
         }
       ],
       "emotionSets": [

docs/examples/results/example-suggestion.json

@@ -2,8 +2,12 @@
   "@context": "http://mixedemotions-project.eu/ns/context.jsonld",
   "@id": "me:Result1",
   "@type": "results",
-  "analysis": [
-      "me:SgAnalysis1"
+  "activities": [
+    {
+      "@id": "_:SgAnalysis1_Activity",
+      "@type": "me:SuggestionAnalysis",
+      "prov:wasAssociatedWith": "me:SgAnalysis1"
+    }
   ],
   "entries": [
     {
@@ -12,7 +16,6 @@
         "nif:RFC5147String",
         "nif:Context"
       ],
-      "prov:wasGeneratedBy": "me:SAnalysis1",
       "nif:isString": "Dear Microsoft, put your Windows Phone on your newest #open technology program. You'll be awesome. #opensource",
       "entities": [
       ],
@@ -22,7 +25,7 @@
           "nif:beginIndex": 16,
           "nif:endIndex": 77,
           "nif:anchorOf": "put your Windows Phone on your newest #open technology program",
-          "prov:wasGeneratedBy": "me:SgAnalysis1"
+          "prov:wasGeneratedBy": "_:SgAnalysis1_Activity"
         }
       ],
       "sentiments": [

docs/index.rst

@@ -1,35 +1,35 @@
 Welcome to Senpy's documentation!
 =================================
-.. image:: https://readthedocs.org/projects/senpy/badge/?version=latest
-   :target: http://senpy.readthedocs.io/en/latest/
-.. image:: https://badge.fury.io/py/senpy.svg
-   :target: https://badge.fury.io/py/senpy
-.. image:: https://lab.cluster.gsi.dit.upm.es/senpy/senpy/badges/master/build.svg
-   :target: https://lab.cluster.gsi.dit.upm.es/senpy/senpy/commits/master
-.. image:: https://lab.cluster.gsi.dit.upm.es/senpy/senpy/badges/master/coverage.svg
-   :target: https://lab.cluster.gsi.dit.upm.es/senpy/senpy/commits/master
-.. image:: https://img.shields.io/pypi/l/requests.svg
-   :target: https://lab.cluster.gsi.dit.upm.es/senpy/senpy/
 
+.. image:: https://readthedocs.org/projects/senpy/badge/?version=latest
+  :target: http://senpy.readthedocs.io/en/latest/
+.. image:: https://badge.fury.io/py/senpy.svg
+  :target: https://badge.fury.io/py/senpy
+.. image:: https://lab.gsi.upm.es/senpy/senpy/badges/master/build.svg
+  :target: https://lab.gsi.upm.es/senpy/senpy/commits/master
+.. image:: https://lab.gsi.upm.es/senpy/senpy/badges/master/coverage.svg
+  :target: https://lab.gsi.upm.es/senpy/senpy/commits/master
+.. image:: https://img.shields.io/pypi/l/requests.svg
+  :target: https://lab.gsi.upm.es/senpy/senpy/
 
 
 Senpy is a framework for sentiment and emotion analysis services.
-Services built with senpy are interchangeable and easy to use because they share a common :doc:`apischema`.
-It also simplifies service development.
+Senpy services are interchangeable and easy to use because they share a common semantic :doc:`apischema`.
+
+If you interested in consuming Senpy services, read :doc:`Quickstart`.
+To get familiar with the concepts behind Senpy, and what it can offer for service developers, check out :doc:`development`.
+:doc:`apischema` contains information about the semantic models and vocabularies used by Senpy.
 
-.. image:: senpy-architecture.png
-  :width: 100%
-  :align: center
 
 .. toctree::
-   :caption: Learn more about senpy:
-   :maxdepth: 2
+  :caption: Learn more about senpy:
+  :maxdepth: 2
+
+  senpy
+  demo
+  Quickstart.ipynb
+  installation
+  apischema
+  advanced
+  publications
 
-   senpy
-   installation
-   demo
-   usage
-   apischema
-   plugins
-   conversion
-   about

docs/installation.rst

@@ -32,27 +32,25 @@ If you want to install senpy globally, use sudo instead of the ``--user`` flag.
 
 Docker Image
 ************
-Build the image or use the pre-built one:   
+The base image of senpy comes with some builtin plugins that you can use:   
 
 .. code:: bash
 
-   docker run -ti -p 5000:5000 gsiupm/senpy --host 0.0.0.0 --default-plugins
+   docker run -ti -p 5000:5000 gsiupm/senpy --host 0.0.0.0
 
-To add custom plugins, use a docker volume: 
+To add your custom plugins, you can use a docker volume: 
     
 .. code:: bash
 
-   docker run -ti -p 5000:5000 -v <PATH OF PLUGINS>:/plugins gsiupm/senpy --host 0.0.0.0 --default-plugins -f /plugins
+   docker run -ti -p 5000:5000 -v <PATH OF PLUGINS>:/plugins gsiupm/senpy --host 0.0.0.0 --plugins -f /plugins
  
 
-Python 2
-........
 
-There is a Senpy version for python2 too:
+There is a Senpy image for **python 2**, too:
     
 .. code:: bash
 
-   docker run -ti -p 5000:5000 gsiupm/senpy:python2.7 --host 0.0.0.0 --default-plugins
+   docker run -ti -p 5000:5000 gsiupm/senpy:python2.7 --host 0.0.0.0
 
 
 Alias
@@ -62,7 +60,7 @@ If you are using the docker approach regularly, it is advisable to use a script
 
 .. code:: bash
 
-   alias senpy='docker run --rm -ti -p 5000:5000 -v $PWD:/senpy-plugins gsiupm/senpy --default-plugins'
+   alias senpy='docker run --rm -ti -p 5000:5000 -v $PWD:/senpy-plugins gsiupm/senpy'
 
 
 Now, you may run senpy from any folder in your computer like so:

docs/plugins-definition.rst

@@ -0,0 +1,113 @@
+Advanced plugin definition
+--------------------------
+In addition to finding plugins defined in source code files, senpy can also load a special type of definition file (`.senpy` files).
+This used to be the only mechanism for loading in earlier versions of senpy.
+
+The definition file contains basic information 
+
+Lastly, it is also possible to add new plugins programmatically.
+
+.. contents:: :local:
+
+What is a plugin?
+=================
+
+A plugin is a program that, given a text, will add annotations to it.
+In practice, a plugin consists of at least two files:
+
+- Definition file: a `.senpy` file that describes the plugin (e.g. what input parameters it accepts, what emotion model it uses).
+- Python module: the actual code that will add annotations to each input.
+
+This separation allows us to deploy plugins that use the same code but employ different parameters.
+For instance, one could use the same classifier and processing in several plugins, but train with different datasets.
+This scenario is particularly useful for evaluation purposes.
+
+The only limitation is that the name of each plugin needs to be unique.
+
+Definition files
+================
+
+The definition file complements and overrides the attributes provided by the plugin.
+It can be written in YAML or JSON.
+The most important attributes are:
+
+* **name**: unique name that senpy will use internally to identify the plugin.
+* **module**: indicates the module that contains the plugin code, which will be automatically loaded by senpy.
+* **version**
+* extra_params: to add parameters to the senpy API when this plugin is requested. Those parameters may be required, and have aliased names. For instance:
+
+  .. code:: yaml
+
+            extra_params:
+                hello_param:
+                    aliases: # required
+                        - hello_param
+                        - hello
+                    required: true
+                    default: Hi you
+                    values:
+                        - Hi you
+                        - Hello y'all
+                        - Howdy
+
+A complete example:
+
+.. code:: yaml
+          
+          name: <Name of the plugin>
+          module: <Python file>
+          version: 0.1
+
+And the json equivalent:
+
+.. code:: json
+
+          {
+            "name": "<Name of the plugin>",
+            "module": "<Python file>",
+            "version": "0.1"
+          }
+
+
+Example plugin with a definition file
+=====================================
+
+In this section, we will implement a basic sentiment analysis plugin.
+To determine the polarity of each entry, the plugin will compare the length of the string to a threshold.
+This threshold will be included in the definition file.
+
+The definition file would look like this:
+
+.. code:: yaml
+
+          name: helloworld
+          module: helloworld
+          version: 0.0
+          threshold: 10
+          description: Hello World
+
+Now, in a file named ``helloworld.py``:
+
+.. code:: python
+
+          #!/bin/env python
+          #helloworld.py
+
+          from senpy import AnalysisPlugin
+          from senpy import Sentiment
+
+
+          class HelloWorld(AnalysisPlugin):
+
+              def analyse_entry(entry, params):
+                  '''Basically do nothing with each entry'''
+
+                  sentiment = Sentiment()
+                  if len(entry.text) < self.threshold:
+                      sentiment['marl:hasPolarity'] = 'marl:Positive'
+                  else:
+                      sentiment['marl:hasPolarity'] = 'marl:Negative'
+                  entry.sentiments.append(sentiment)
+                  yield entry
+
+The complete code of the example plugin is available `here <https://lab.gsi.upm.es/senpy/plugin-prueba>`__.

docs/plugins-faq.rst

@@ -0,0 +1,258 @@
+F.A.Q.
+======
+
+.. contents:: :local:
+
+
+
+What are annotations?
+#####################
+They are objects just like entries.
+Senpy ships with several default annotations, including: ``Sentiment``, ``Emotion``, ``EmotionSet``...jk bb
+
+
+What's a plugin made of?
+########################
+
+When receiving a query, senpy selects what plugin or plugins should process each entry, and in what order.
+It also makes sure the every entry and the parameters provided by the user meet the plugin requirements.
+
+Hence, two parts are necessary: 1) the code that will process the entry, and 2) some attributes and metadata that will tell senpy how to interact with the plugin.
+
+In practice, this is what a plugin looks like, tests included:
+
+
+.. literalinclude:: ../example-plugins/rand_plugin.py
+   :emphasize-lines: 5-11
+   :language: python
+
+
+The lines highlighted contain some information about the plugin.
+In particular, the following information is mandatory:
+
+* A unique name for the class. In our example, sentiment-random.
+* The subclass/type of plugin. This is typically either `SentimentPlugin` or `EmotionPlugin`. However, new types of plugin can be created for different annotations. The only requirement is that these new types inherit from `senpy.Analysis`
+* A description of the plugin. This can be done simply by adding a doc to the class.
+* A version, which should get updated.
+* An author name.
+
+
+How does senpy find modules?
+############################
+
+Senpy looks for files of two types:
+
+* Python files of the form `senpy_<NAME>.py` or `<NAME>_plugin.py`. In these files, it will look for: 1) Instances that inherit from `senpy.Plugin`, or subclasses of `senpy.Plugin` that can be initialized without a configuration file. i.e. classes that contain all the required attributes for a plugin.
+* Plugin definition files (see :doc:`plugins-definition`)
+
+How can I define additional parameters for my plugin?
+#####################################################
+
+Your plugin may ask for additional parameters from users by using the attribute ``extra_params`` in your plugin definition.
+It takes a dictionary, where the keys are the name of the argument/parameter, and the value has the following fields:
+
+* aliases: the different names which can be used in the request to use the parameter.
+* required: if set to true, users need to provide this parameter unless a default is set.
+* options: the different acceptable values of the parameter (i.e. an enum). If set, the value provided must match one of the options.
+* default: the default value of the parameter, if none is provided in the request.
+
+.. code:: python
+
+          "extra_params":{
+             "language": {
+                "aliases": ["language", "lang", "l"],
+                "required": True,
+                "options": ["es", "en"],
+                "default": "es"
+                }
+             }
+
+
+
+How should I load external data and files
+#########################################
+
+Most plugins will need access to files (dictionaries, lexicons, etc.).
+These files are usually heavy or under a license that does not allow redistribution.
+For this reason, senpy has a `data_folder` that is separated from the source files.
+The location of this folder is controlled programmatically or by setting the `SENPY_DATA` environment variable.
+You can use the `self.path(filepath)` function to get the path of a given `filepath` within the data folder.
+
+Plugins have a convenience function `self.open` which will automatically look for the file if it exists, or open a new one if it doesn't:
+
+
+.. code:: python
+
+          import os
+
+
+          class PluginWithResources(AnalysisPlugin):
+              file_in_data = <FILE PATH>
+              file_in_sources = <FILE PATH>
+
+              def on activate(self):
+                  with self.open(self.file_in_data) as f:
+                      self._classifier = train_from_file(f)
+                  file_in_source = os.path.join(self.get_folder(), self.file_in_sources)
+                  with self.open(file_in_source) as f:
+                      pass
+
+         
+It is good practice to specify the paths of these files in the plugin configuration, so the same code can be reused with different resources.
+
+
+Can I build a docker image for my plugin?
+#########################################
+
+Add the following dockerfile to your project to generate a docker image with your plugin:
+
+.. code:: dockerfile
+
+   FROM gsiupm/senpy
+
+Once you make sure your plugin works with a specific version of senpy, modify that file to make sure your build will work even if senpy gets updated.
+e.g.:
+
+
+.. code:: dockerfile
+
+   FROM gsiupm/senpy:1.0.1
+
+     
+This will copy your source folder to the image, and install all dependencies.
+Now, to build an image:
+
+.. code:: shell
+
+   docker build . -t gsiupm/exampleplugin
+
+And you can run it with:
+
+.. code:: shell
+
+   docker run -p 5000:5000 gsiupm/exampleplugin
+
+
+If the plugin uses non-source files (:ref:`How should I load external data and files`), the recommended way is to use `SENPY_DATA` folder.
+Data can then be mounted in the container or added to the image.
+The former is recommended for open source plugins with licensed resources, whereas the latter is the most convenient and can be used for private images.
+
+Mounting data:
+
+.. code:: bash
+
+   docker run -v $PWD/data:/data gsiupm/exampleplugin
+
+Adding data to the image:
+
+.. code:: dockerfile
+
+   FROM gsiupm/senpy:1.0.1
+   COPY data /
+
+What annotations can I use?
+###########################
+
+You can add almost any annotation to an entry.
+The most common use cases are covered in the :doc:`apischema`.
+
+
+Why does the analyse function yield instead of return?
+######################################################
+
+This is so that plugins may add new entries to the response or filter some of them.
+For instance, a chunker may split one entry into several.
+On the other hand, a conversion plugin may leave out those entries that do not contain relevant information.
+
+
+If I'm using a classifier, where should I train it?
+###################################################
+
+Training a classifier can be time time consuming. To avoid running the training unnecessarily, you can use ShelfMixin to store the classifier. For instance:
+
+.. code:: python
+
+          from senpy.plugins import ShelfMixin, AnalysisPlugin
+
+          class MyPlugin(ShelfMixin, AnalysisPlugin):
+              def train(self):
+                  ''' Code to train the classifier
+                  '''
+                  # Here goes the code
+                  # ...
+                  return classifier
+
+              def activate(self):
+                  if 'classifier' not in self.sh:
+                      classifier = self.train()
+                      self.sh['classifier'] = classifier
+                  self.classifier = self.sh['classifier']
+              
+              def deactivate(self):
+                  self.close()
+
+
+By default the ShelfMixin creates a file based on the plugin name and stores it in that plugin's folder.
+However, you can manually specify a 'shelf_file' in your .senpy file.
+
+Shelves may get corrupted if the plugin exists unexpectedly.
+A corrupt shelf prevents the plugin from loading.
+If you do not care about the data in the shelf, you can force your plugin to remove the corrupted file and load anyway, set the  'force_shelf' to True in your plugin and start it again.
+
+How can I turn an external service into a plugin?
+#################################################
+
+This example ilustrate how to implement a plugin that accesses the Sentiment140 service.
+
+.. code:: python
+
+          class Sentiment140Plugin(SentimentPlugin):
+              def analyse_entry(self, entry, params):
+                  text = entry.text
+                  lang = params.get("language", "auto")
+                  res = requests.post("http://www.sentiment140.com/api/bulkClassifyJson",
+                                      json.dumps({"language": lang,
+                                                  "data": [{"text": text}]
+                                                  }
+                                                 )
+                                      )
+
+                  p = params.get("prefix", None)
+                  polarity_value = self.maxPolarityValue*int(res.json()["data"][0]
+                                                             ["polarity"]) * 0.25
+                  polarity = "marl:Neutral"
+                  neutral_value = self.maxPolarityValue / 2.0
+                  if polarity_value > neutral_value:
+                      polarity = "marl:Positive"
+                  elif polarity_value < neutral_value:
+                      polarity = "marl:Negative"
+
+                  sentiment = Sentiment(id="Sentiment0",
+                                      prefix=p,
+                                      marl__hasPolarity=polarity,
+                                      marl__polarityValue=polarity_value)
+                  sentiment.prov(self)
+                  entry.sentiments.append(sentiment)
+                  yield entry
+
+
+How can I activate a DEBUG mode for my plugin?
+###############################################
+
+You can activate the DEBUG mode by the command-line tool using the option -d.
+
+.. code:: bash
+
+   senpy -d
+
+
+Additionally, with the ``--pdb`` option you will be dropped into a pdb post mortem shell if an exception is raised.
+
+.. code:: bash
+
+   python -m pdb yourplugin.py
+
+Where can I find more code examples?
+####################################
+
+See: `<http://github.com/gsi-upm/senpy-plugins-community>`_.

docs/plugins-quickstart.rst

@@ -0,0 +1,86 @@
+Quickstart for service developers
+=================================
+ 
+This document contains the minimum to get you started with developing new services using Senpy.
+
+For an example of conversion plugins, see :doc:`conversion`.
+For a description of definition files, see :doc:`plugins-definition`.
+
+A more step-by-step tutorial with slides is available `here <https://lab.gsi.upm.es/senpy/senpy-tutorial>`__ 
+
+.. contents:: :local:
+
+Installation
+############
+
+First of all, you need to install the package.
+See :doc:`installation` for instructions.
+Once installed, the `senpy` command should be available. 
+
+Architecture
+############
+
+The main component of a sentiment analysis service is the algorithm itself. However, for the algorithm to work, it needs to get the appropriate parameters from the user, format the results according to the defined API, interact with the user whn errors occur or more information is needed, etc.
+
+Senpy proposes a modular and dynamic architecture that allows:
+
+* Implementing different algorithms in a extensible way, yet offering a common interface.
+* Offering common services that facilitate development, so developers can focus on implementing new and better algorithms.
+
+The framework consists of two main modules: Senpy core, which is the building block of the service, and Senpy plugins, which consist of the analysis algorithm. The next figure depicts a simplified version of the processes involved in an analysis with the Senpy framework.
+
+.. image:: senpy-architecture.png
+  :width: 100%
+  :align: center
+
+
+What is a plugin?
+#################
+
+A plugin is a python object that can process entries. Given an entry, it will modify it, add annotations to it, or generate new entries.
+
+
+What is an entry?
+#################
+
+Entries are objects that can be annotated.
+In general, they will be a piece of text.
+By default, entries are `NIF contexts <http://persistence.uni-leipzig.org/nlp2rdf/ontologies/nif-core/nif-core.html>`_ represented in JSON-LD format.
+It is a dictionary/JSON object that looks like this:
+
+  .. code:: python
+
+            {
+               "@id": "<unique identifier or blank node name>",
+               "nif:isString": "input text",
+               "sentiments": [ {
+                     ...
+               }
+               ],
+               ...
+            }
+
+Annotations are added to the object like this:
+
+.. code:: python
+
+   entry = Entry()
+   entry.vocabulary__annotationName = 'myvalue'
+   entry['vocabulary:annotationName'] = 'myvalue'
+   entry['annotationNameURI'] = 'myvalue'
+
+Where vocabulary is one of the prefixes defined in the default senpy context, and annotationURI is a full URI.
+The value may be any valid JSON-LD dictionary.
+For simplicity, senpy includes a series of models by default in the ``senpy.models`` module.
+
+Plugins Code
+############
+
+The basic methods in a plugin are:
+
+* analyse_entry: called in every user requests. It takes two parameters: ``Entry``, the entry object, and ``params``, the parameters supplied by the user. It should yield one or more ``Entry`` objects.
+* activate: used to load memory-hungry resources. For instance, to train a classifier.
+* deactivate: used to free up resources when the plugin is no longer needed.
+
+Plugins are loaded asynchronously, so don't worry if the activate method takes too long. The plugin will be marked as activated once it is finished executing the method.
+

docs/plugins.rst

@@ -1,379 +0,0 @@
-Developing new plugins
-----------------------
-This document describes how to develop a new analysis plugin. For an example of conversion plugins, see :doc:`conversion`.
-
-A more step-by-step tutorial with slides is available `here <https://lab.cluster.gsi.dit.upm.es/senpy/senpy-tutorial>`__ 
-
-.. contents:: :local:
-
-What is a plugin?
-=================
-
-A plugin is a program that, given a text, will add annotations to it.
-In practice, a plugin consists of at least two files:
-
-- Definition file: a `.senpy` file that describes the plugin (e.g. what input parameters it accepts, what emotion model it uses).
-- Python module: the actual code that will add annotations to each input.
-
-This separation allows us to deploy plugins that use the same code but employ different parameters.
-For instance, one could use the same classifier and processing in several plugins, but train with different datasets.
-This scenario is particularly useful for evaluation purposes.
-
-The only limitation is that the name of each plugin needs to be unique.
-
-Plugin Definition files
-=======================
-
-The definition file contains all the attributes of the plugin, and can be written in YAML or JSON.
-When the server is launched, it will recursively search for definition files in the plugin folder (the current folder, by default).
-The most important attributes are:
-
-* **name**: unique name that senpy will use internally to identify the plugin.
-* **module**: indicates the module that contains the plugin code, which will be automatically loaded by senpy.
-* **version**
-* extra_params: to add parameters to the senpy API when this plugin is requested. Those parameters may be required, and have aliased names. For instance:
-
-  .. code:: yaml
-
-            extra_params:
-                hello_param:
-                    aliases: # required
-                        - hello_param
-                        - hello
-                    required: true
-                    default: Hi you
-                    values:
-                        - Hi you
-                        - Hello y'all
-                        - Howdy
-
-  Parameter validation will fail if a required parameter without a default has not been provided, or if the definition includes a set of values and the provided one does not match one of them.
-
-
-A complete example:
-
-.. code:: yaml
-          
-          name: <Name of the plugin>
-          module: <Python file>
-          version: 0.1
-
-And the json equivalent:
-
-.. code:: json
-
-          {
-            "name": "<Name of the plugin>",
-            "module": "<Python file>",
-            "version": "0.1"
-          }
-
-
-Plugins Code
-============
-
-The basic methods in a plugin are:
-
-* __init__
-* activate: used to load memory-hungry resources
-* deactivate: used to free up resources
-* analyse_entry: called in every user requests. It takes two parameters: ``Entry``, the entry object, and ``params``, the parameters supplied by the user. It should yield one or more ``Entry`` objects.
-
-Plugins are loaded asynchronously, so don't worry if the activate method takes too long. The plugin will be marked as activated once it is finished executing the method.
-
-Entries
-=======
-
-Entries are objects that can be annotated.
-By default, entries are `NIF contexts <http://persistence.uni-leipzig.org/nlp2rdf/ontologies/nif-core/nif-core.html>`_ represented in JSON-LD format.
-Annotations are added to the object like this:
-
-.. code:: python
-
-   entry = Entry()
-   entry.vocabulary__annotationName = 'myvalue'
-   entry['vocabulary:annotationName'] = 'myvalue'
-   entry['annotationNameURI'] = 'myvalue'
-
-Where vocabulary is one of the prefixes defined in the default senpy context, and annotationURI is a full URI.
-The value may be any valid JSON-LD dictionary.
-For simplicity, senpy includes a series of models by default in the ``senpy.models`` module.
-
-
-Example plugin
-==============
-
-In this section, we will implement a basic sentiment analysis plugin.
-To determine the polarity of each entry, the plugin will compare the length of the string to a threshold.
-This threshold will be included in the definition file.
-
-The definition file would look like this:
-
-.. code:: yaml
-
-          name: helloworld
-          module: helloworld
-          version: 0.0
-          threshold: 10
-          description: Hello World
-
-Now, in a file named ``helloworld.py``:
-
-.. code:: python
-
-          #!/bin/env python
-          #helloworld.py
-
-          from senpy.plugins import AnalysisPlugin
-          from senpy.models import Sentiment
-
-
-          class HelloWorld(AnalysisPlugin):
-
-              def analyse_entry(entry, params):
-                  '''Basically do nothing with each entry'''
-
-                  sentiment = Sentiment()
-                  if len(entry.text) < self.threshold:
-                      sentiment['marl:hasPolarity'] = 'marl:Positive'
-                  else:
-                      sentiment['marl:hasPolarity'] = 'marl:Negative'
-                  entry.sentiments.append(sentiment)
-                  yield entry
-
-The complete code of the example plugin is available `here <https://lab.cluster.gsi.dit.upm.es/senpy/plugin-prueba>`__.
-
-Loading data and files
-======================
-
-Most plugins will need access to files (dictionaries, lexicons, etc.).
-It is good practice to specify the paths of these files in the plugin configuration, so the same code can be reused with different resources.
-
-
-.. code:: yaml
-
-          name: dictworld
-          module: dictworld
-          dictionary_path: <PATH OF THE FILE>
-         
-The path can be either absolute, or relative.
-
-From absolute paths
-???????????????????
-
-Absolute paths (such as ``/data/dictionary.csv`` are straightfoward:
-
-.. code:: python
-
-   with open(os.path.join(self.dictionary_path) as f:
-      ...
-
-From relative paths
-???????????????????
-Since plugins are loading dynamically, relative paths will refer to the current working directory.
-Instead, what you usually want is to load files *relative to the plugin source folder*, like so:
-
-
-:: 
-
-   .
-   ..
-   plugin.senpy
-   plugin.py
-   dictionary.csv
-
-For this, we need to first get the path of your source folder first, like so:
-
-.. code:: python
-
-   import os
-   root = os.path.realpath(__file__)
-   with open(os.path.join(root, self.dictionary_path) as f:
-       ...
-
-
-Docker image
-============
-
-Add the following dockerfile to your project to generate a docker image with your plugin:
-
-.. code:: dockerfile
-
-   FROM gsiupm/senpy:0.8.8
-
-This will copy your source folder to the image, and install all dependencies.
-Now, to build an image:
-
-.. code:: shell
-
-   docker build . -t gsiupm/exampleplugin
-
-And you can run it with:
-
-.. code:: shell
-
-   docker run -p 5000:5000 gsiupm/exampleplugin
-
-
-If the plugin non-source files (:ref:`loading data and files`), the recommended way is to use absolute paths.
-Data can then be mounted in the container or added to the image.
-The former is recommended for open source plugins with licensed resources, whereas the latter is the most convenient and can be used for private images.
-
-Mounting data:
-
-.. code:: bash
-
-   docker run -v $PWD/data:/data gsiupm/exampleplugin
-
-Adding data to the image:
-
-.. code:: dockerfile
-
-   FROM gsiupm/senpy:0.8.8
-   COPY data /
-
-F.A.Q.
-======
-What annotations can I use?
-???????????????????????????
-
-You can add almost any annotation to an entry.
-The most common use cases are covered in the :doc:`apischema`.
-
-
-Why does the analyse function yield instead of return?
-??????????????????????????????????????????????????????
-
-This is so that plugins may add new entries to the response or filter some of them.
-For instance, a `context detection` plugin may add a new entry for each context in the original entry.
-On the other hand, a conversion plugin may leave out those entries that do not contain relevant information.
-
-
-If I'm using a classifier, where should I train it?
-???????????????????????????????????????????????????
-
-Training a classifier can be time time consuming. To avoid running the training unnecessarily, you can use ShelfMixin to store the classifier. For instance:
-
-.. code:: python
-
-          from senpy.plugins import ShelfMixin, AnalysisPlugin
-
-          class MyPlugin(ShelfMixin, AnalysisPlugin):
-              def train(self):
-                  ''' Code to train the classifier
-                  '''
-                  # Here goes the code
-                  # ...
-                  return classifier
-
-              def activate(self):
-                  if 'classifier' not in self.sh:
-                      classifier = self.train()
-                      self.sh['classifier'] = classifier
-                  self.classifier = self.sh['classifier']
-              
-              def deactivate(self):
-                  self.close()
-
-You can specify a 'shelf_file' in your .senpy file. By default the ShelfMixin creates a file based on the plugin name and stores it in that plugin's folder.
-
-Shelves may get corrupted if the plugin exists unexpectedly.
-A corrupt shelf prevents the plugin from loading.
-If you do not care about the pickle, you can force your plugin to remove the corrupted file and load anyway, set the  'force_shelf' to True in your .senpy file.
-
-How can I turn an external service into a plugin?
-?????????????????????????????????????????????????
-
-This example ilustrate how to implement a plugin that accesses the Sentiment140 service.
-
-.. code:: python
-
-          class Sentiment140Plugin(SentimentPlugin):
-              def analyse_entry(self, entry, params):
-                  text = entry.text
-                  lang = params.get("language", "auto")
-                  res = requests.post("http://www.sentiment140.com/api/bulkClassifyJson",
-                                      json.dumps({"language": lang,
-                                                  "data": [{"text": text}]
-                                                  }
-                                                 )
-                                      )
-
-                  p = params.get("prefix", None)
-                  polarity_value = self.maxPolarityValue*int(res.json()["data"][0]
-                                                             ["polarity"]) * 0.25
-                  polarity = "marl:Neutral"
-                  neutral_value = self.maxPolarityValue / 2.0
-                  if polarity_value > neutral_value:
-                      polarity = "marl:Positive"
-                  elif polarity_value < neutral_value:
-                      polarity = "marl:Negative"
-
-                  sentiment = Sentiment(id="Sentiment0",
-                                      prefix=p,
-                                      marl__hasPolarity=polarity,
-                                      marl__polarityValue=polarity_value)
-                  sentiment.prov__wasGeneratedBy = self.id
-                  entry.sentiments.append(sentiment)
-                  yield entry
-
-
-Can my plugin require additional parameters from the user?
-??????????????????????????????????????????????????????????
-
-You can add extra parameters in the definition file under the attribute ``extra_params``.
-It takes a dictionary, where the keys are the name of the argument/parameter, and the value has the following fields:
-
-* aliases: the different names which can be used in the request to use the parameter.
-* required: if set to true, users need to provide this parameter unless a default is set.
-* options: the different acceptable values of the parameter (i.e. an enum). If set, the value provided must match one of the options.
-* default: the default value of the parameter, if none is provided in the request.
-
-.. code:: python
-
-          extra_params
-             language:
-                aliases:
-                    - language
-                    - lang
-                    - l
-                required: true,
-                options:
-                    - es
-                    - en
-                default: es
-
-This example shows how to introduce a parameter associated with language.
-The extraction of this paremeter is used in the analyse method of the Plugin interface.
-
-.. code:: python
-
-          lang = params.get("language")
-
-Where can I set up variables for using them in my plugin?
-?????????????????????????????????????????????????????????
-
-You can add these variables in the definition file with the structure of attribute-value pairs.
-
-Every field added to the definition file is available to the plugin instance.
-
-Can I activate a DEBUG mode for my plugin?
-???????????????????????????????????????????
-
-You can activate the DEBUG mode by the command-line tool using the option -d.
-
-.. code:: bash
-
-   senpy -d
-
-
-Additionally, with the ``--pdb`` option you will be dropped into a pdb post mortem shell if an exception is raised.
-
-.. code:: bash
-
-   senpy --pdb
-
-Where can I find more code examples?
-????????????????????????????????????
-
-See: `<http://github.com/gsi-upm/senpy-plugins-community>`_.

docs/publications.rst

@@ -0,0 +1,46 @@
+Publications
+============
+
+
+If you use Senpy in your research, please cite `Senpy: A Pragmatic Linked Sentiment Analysis Framework <http://gsi.dit.upm.es/index.php/es/investigacion/publicaciones?view=publication&task=show&id=417>`__ (`BibTex <http://gsi.dit.upm.es/index.php/es/investigacion/publicaciones?controller=publications&task=export&format=bibtex&id=417>`__):
+
+.. code-block:: text
+
+	Sánchez-Rada, J. F., Iglesias, C. A., Corcuera, I., & Araque, Ó. (2016, October).
+	Senpy: A Pragmatic Linked Sentiment Analysis Framework.
+	In Data Science and Advanced Analytics (DSAA),
+	2016 IEEE International Conference on (pp. 735-742). IEEE.
+
+
+
+Senpy uses Onyx for emotion representation, first introduced in:
+
+.. code-block:: text
+
+    Sánchez-Rada, J. F., & Iglesias, C. A. (2016).
+    Onyx: A linked data approach to emotion representation.
+    Information Processing & Management, 52(1), 99-114.
+
+Senpy uses Marl for sentiment representation, which was presented in:
+
+.. code-block:: text
+
+    Westerski, A., Iglesias Fernandez, C. A., & Tapia Rico, F. (2011).
+    Linked opinions: Describing sentiments on the structured web of data.
+
+
+Senpy has been used extensively in the toolbox of the MixedEmotions project:
+
+.. code-block:: text
+
+    Buitelaar, P., Wood, I. D., Arcan, M., McCrae, J. P., Abele, A., Robin, C., … Tummarello, G. (2018). 
+    MixedEmotions: An Open-Source Toolbox for Multi-Modal Emotion Analysis.
+    IEEE Transactions on Multimedia.
+
+The representation models, formats and challenges are partially covered in a chapter of the book Sentiment Analysis in Social Networks:
+
+.. code-block:: text
+
+    Iglesias, C. A., Sánchez-Rada, J. F., Vulcu, G., & Buitelaar, P. (2017).
+    Linked Data Models for Sentiment and Emotion Analysis in Social Networks.
+    In Sentiment Analysis in Social Networks (pp. 49-69).

docs/requirements.txt

@@ -1,2 +1,3 @@
 sphinxcontrib-httpdomain>=1.4
+ipykernel
 nbsphinx

docs/senpy.rst

@@ -1,51 +1,27 @@
 What is Senpy?
 --------------
 
-Web services can get really complex: data validation, user interaction, formatting, logging., etc. 
-The figure below summarizes the typical features in an analysis service.
-Senpy implements all the common blocks, so developers can focus on what really matters: great analysis algorithms that solve real problems.
-
-.. image:: senpy-framework.png
-  :width: 60%
-  :align: center
-
-
-Senpy for end users
-===================
-
-All services built using senpy share a common interface.
-This allows users to use them (almost) interchangeably.
-Senpy comes with a :ref:`built-in client`.
-
-
-Senpy for service developers
-============================
-
-Senpy is a framework that turns your sentiment or emotion analysis algorithm into a full blown semantic service.
-Senpy takes care of:
-
-  * Interfacing with the user: parameter validation, error handling.
-  * Formatting: JSON-LD, Turtle/n-triples input and output, or simple text input
-  * Linked Data: senpy results are semantically annotated, using a series of well established vocabularies, and sane default URIs.
-  * User interface: a web UI where users can explore your service and test different settings
-  * A client to interact with the service. Currently only available in Python.
-
-Sharing your sentiment analysis with the world has never been easier!
-
-Check out the :doc:`plugins` if you have developed an analysis algorithm (e.g. sentiment analysis) and you want to publish it as a service.
-
-Architecture
-============
-
-The main component of a sentiment analysis service is the algorithm itself. However, for the algorithm to work, it needs to get the appropriate parameters from the user, format the results according to the defined API, interact with the user whn errors occur or more information is needed, etc.
-
-Senpy proposes a modular and dynamic architecture that allows:
-
-* Implementing different algorithms in a extensible way, yet offering a common interface.
-* Offering common services that facilitate development, so developers can focus on implementing new and better algorithms.
-
-The framework consists of two main modules: Senpy core, which is the building block of the service, and Senpy plugins, which consist of the analysis algorithm. The next figure depicts a simplified version of the processes involved in an analysis with the Senpy framework.
+Senpy is a framework for sentiment and emotion analysis services.
+Its goal is to produce analysis services that are interchangeable and fully interoperable.
 
 .. image:: senpy-architecture.png
   :width: 100%
   :align: center
+
+All services built using senpy share a common interface.
+This allows users to use them (almost) interchangeably, with the same API and tools, simply by pointing to a different URL or changing a parameter.
+The common schema also makes it easier to evaluate the performance of different algorithms and services.
+In fact, Senpy has a built-in evaluation API you can use to compare results with different algorithms.
+
+Services can also use the common interface to communicate with each other.
+And higher level features can be built on top of these services, such as automatic fusion of results, emotion model conversion, and service discovery.
+
+These benefits are not limited to new services.
+The community has developed wrappers for some proprietary and commercial services (such as sentiment140 and Meaning Cloud), so you can consult them as.
+Senpy comes with a built-in client in the client package.
+
+
+To achieve this goal, Senpy uses a Linked Data principled approach, based on the NIF (NLP Interchange Format) specification, and open vocabularies such as Marl and Onyx.
+You can learn more about this in :doc:`vocabularies`.
+
+Check out :doc:`development` if you have developed an analysis algorithm (e.g. sentiment analysis) and you want to publish it as a service.

docs/server-cli.rst

@@ -0,0 +1,72 @@
+Server
+======
+
+The senpy server is launched via the `senpy` command:
+
+.. code:: text
+
+    usage: senpy [-h] [--level logging_level] [--log-format log_format] [--debug]
+                [--no-default-plugins] [--host HOST] [--port PORT]
+                [--plugins-folder PLUGINS_FOLDER] [--only-install] [--only-test]
+                [--test] [--only-list] [--data-folder DATA_FOLDER]
+                [--no-threaded] [--no-deps] [--version] [--allow-fail]
+
+    Run a Senpy server
+
+    optional arguments:
+      -h, --help            show this help message and exit
+      --level logging_level, -l logging_level
+                            Logging level
+      --log-format log_format
+                            Logging format
+      --debug, -d           Run the application in debug mode
+      --no-default-plugins  Do not load the default plugins
+      --host HOST           Use 0.0.0.0 to accept requests from any host.
+      --port PORT, -p PORT  Port to listen on.
+      --plugins-folder PLUGINS_FOLDER, -f PLUGINS_FOLDER
+                            Where to look for plugins.
+      --only-install, -i    Do not run a server, only install plugin dependencies
+      --only-test           Do not run a server, just test all plugins
+      --test, -t            Test all plugins before launching the server
+      --only-list, --list   Do not run a server, only list plugins found
+      --data-folder DATA_FOLDER, --data DATA_FOLDER
+                            Where to look for data. It be set with the SENPY_DATA
+                            environment variable as well.
+      --no-threaded         Run the server without threading
+      --no-deps, -n         Skip installing dependencies
+      --version, -v         Output the senpy version and exit
+      --allow-fail, --fail  Do not exit if some plugins fail to activate
+
+
+When launched, the server will recursively look for plugins in the specified plugins folder (the current working directory by default).
+For every plugin found, it will download its dependencies, and try to activate it.
+The default server includes a playground and an endpoint with all plugins found.
+
+Let's run senpy with the default plugins:
+
+.. code:: bash
+
+    senpy -f .
+
+Now open your browser and go to `http://localhost:5000 <http://localhost:5000>`_, where you should be greeted by the senpy playground:
+
+.. image:: senpy-playground.png
+   :width: 100%
+   :alt: Playground
+
+The playground is a user-friendly way to test your plugins, but you can always use the service directly:  `http://localhost:5000/api?input=hello <http://localhost:5000/api?input=hello>`_.
+
+
+By default, senpy will listen only on `127.0.0.1`.
+That means you can only access the API from your PC (i.e. localhost).
+You can listen on a different address using the `--host` flag (e.g., 0.0.0.0, to allow any computer to access it).
+The default port is 5000.
+You can change it with the `--port` flag. 
+
+For instance, to accept connections on port 6000 on any interface:
+
+.. code:: bash
+
+    senpy --host 0.0.0.0 --port 6000
+
+For more options, see the `--help` page.

docs/server.rst

@@ -1,58 +0,0 @@
-Server
-======
-
-The senpy server is launched via the `senpy` command:
-
-.. code:: text
-
-    usage: senpy [-h] [--level logging_level] [--debug] [--default-plugins]
-                [--host HOST] [--port PORT] [--plugins-folder PLUGINS_FOLDER]
-                [--only-install]
-
-    Run a Senpy server
-
-    optional arguments:
-    -h, --help            show this help message and exit
-    --level logging_level, -l logging_level
-                            Logging level
-    --debug, -d           Run the application in debug mode
-    --default-plugins     Load the default plugins
-    --host HOST           Use 0.0.0.0 to accept requests from any host.
-    --port PORT, -p PORT  Port to listen on.
-    --plugins-folder PLUGINS_FOLDER, -f PLUGINS_FOLDER
-                            Where to look for plugins.
-    --only-install, -i    Do not run a server, only install plugin dependencies
-
-
-When launched, the server will recursively look for plugins in the specified plugins folder (the current working directory by default).
-For every plugin found, it will download its dependencies, and try to activate it.
-The default server includes a playground and an endpoint with all plugins found.
-
-Let's run senpy with the default plugins:
-
-.. code:: bash
-
-    senpy -f . --default-plugins
-
-Now go to `http://localhost:5000 <http://localhost:5000>`_, you should be greeted by the senpy playground:
-
-.. image:: senpy-playground.png
-   :width: 100%
-   :alt: Playground
-
-The playground is a user-friendly way to test your plugins, but you can always use the service directly:  `http://localhost:5000/api?input=hello <http://localhost:5000/api?input=hello>`_.
-
-
-By default, senpy will listen only on the `127.0.0.1` address.
-That means you can only access the API from your (or localhost).
-You can listen on a different address using the `--host` flag (e.g., 0.0.0.0).
-The default port is 5000.
-You can change it with the `--port` flag. 
-
-For instance, to accept connections on port 6000 on any interface:
-
-.. code:: bash
-
-    senpy --host 0.0.0.0 --port 6000
-
-For more options, see the `--help` page.

docs/usage.rst

@@ -1,15 +0,0 @@
-Usage
------
-
-First of all, you need to install the package.
-See :doc:`installation` for instructions.
-Once installed, the `senpy` command should be available. 
-
-.. toctree::
-   :maxdepth: 1
-
-   server
-   SenpyClientUse
-   commandline
-
-

docs/vocabularies.rst

@@ -1,8 +1,24 @@
 Vocabularies and model
 ======================
 
-The model used in Senpy is based on the following vocabularies:
+The model used in Senpy is based on NIF 2.0 [1], which defines a semantic format and API for improving interoperability among natural language processing services.
 
-* Marl, a vocabulary designed to annotate and describe subjetive opinions expressed on the web or in information systems.
-* Onyx, which is built one the same principles as Marl to annotate and describe emotions, and provides interoperability with Emotion Markup Language.
-* NIF 2.0, which defines a semantic format and APO for improving interoperability among natural language processing services
+Senpy has been applied to sentiment and emotion analysis services using the following vocabularies:
+
+* Marl [2,6], a vocabulary designed to annotate and describe subjetive opinions expressed on the web or in information systems.
+* Onyx [3,5], which is built one the same principles as Marl to annotate and describe emotions, and provides interoperability with Emotion Markup Language.
+
+An overview of the vocabularies and their use can be found in [4].
+
+
+[1] Guidelines for developing NIF-based NLP services, Final Community Group Report 22 December 2015 Available at: https://www.w3.org/2015/09/bpmlod-reports/nif-based-nlp-webservices/
+
+[2] Marl Ontology Specification, available at http://www.gsi.dit.upm.es/ontologies/marl/
+
+[3] Onyx Ontology Specification, available at http://www.gsi.dit.upm.es/ontologies/onyx/
+
+[4] Iglesias, C. A., Sánchez-Rada, J. F., Vulcu, G., & Buitelaar, P. (2017). Linked Data Models for Sentiment and Emotion Analysis in Social Networks. In Sentiment Analysis in Social Networks (pp. 49-69).
+
+[5] Sánchez-Rada, J. F., & Iglesias, C. A. (2016). Onyx: A linked data approach to emotion representation. Information Processing & Management, 52(1), 99-114.
+
+[6] Westerski, A., Iglesias Fernandez, C. A., & Tapia Rico, F. (2011). Linked opinions: Describing sentiments on the structured web of data.

example-plugins/README.md

@@ -0,0 +1,23 @@
+This is a collection of plugins that exemplify certain aspects of plugin development with senpy.
+
+The first series of plugins are the `basic` ones.
+Their starting point is a classification function defined in `basic.py`.
+They all include testing and running them as a script will run all tests.
+In ascending order of customization, the plugins are:
+
+* Basic is the simplest plugin of all. It leverages the `SentimentBox` Plugin class to create a plugin out of a classification method, and `MappingMixin` to convert the labels from (`pos`, `neg`) to (`marl:Positive`, `marl:Negative`
+* Basic_box is just like the previous one, but replaces the mixin with a custom function.
+* Basic_configurable is a version of `basic` with a configurable map of emojis for each sentiment.
+* Basic_parameterized like `basic_info`, but users set the map in each query (via `extra_parameters`).
+* Basic_analyse\_entry uses the more general `analyse_entry` method and adds the annotations individually.
+
+
+In rest of the plugins show advanced topics:
+
+* mynoop: shows how to add a definition file with external requirements for a plugin. Doing this with a python-only module would require moving all imports of the requirements to their functions, which is considered bad practice.
+* Async: a barebones example of training a plugin and analyzing data in parallel.
+
+All of the plugins in this folder include a set of test cases and they are periodically tested with the latest version of senpy.
+
+Additioanlly, for an example of stand-alone plugin that can be tested and deployed with docker, take a look at: lab.gsi.upm.es/senpy/plugin-example
+ bbm

example-plugins/async_plugin.py

@@ -1,4 +1,4 @@
-from senpy.plugins import AnalysisPlugin
+from senpy import AnalysisPlugin
 
 import multiprocessing
 
@@ -7,10 +7,15 @@ def _train(process_number):
     return process_number
 
 
-class AsyncPlugin(AnalysisPlugin):
+class Async(AnalysisPlugin):
+    '''An example of an asynchronous module'''
+    author = '@balkian'
+    version = '0.2'
+    sync = False
+
     def _do_async(self, num_processes):
         pool = multiprocessing.Pool(processes=num_processes)
-        values = pool.map(_train, range(num_processes))
+        values = sorted(pool.map(_train, range(num_processes)))
 
         return values
 
@@ -22,5 +27,11 @@ class AsyncPlugin(AnalysisPlugin):
         entry.async_values = values
         yield entry
 
-    def test(self):
-        pass
+    test_cases = [
+        {
+            'input': 'any',
+            'expected': {
+                'async_values': [0, 1]
+            }
+        }
+    ]

example-plugins/basic.py

@@ -0,0 +1,25 @@
+#!/usr/local/bin/python
+# -*- coding: utf-8 -*-
+
+emoticons = {
+    'pos': [':)', ':]', '=)', ':D'],
+    'neg': [':(', ':[', '=(']
+}
+
+emojis = {
+    'pos': [u'😁', u'😂', u'😃', u'😄', u'😆', u'😅', u'😄', u'😍'],
+    'neg': [u'😢', u'😡', u'😠', u'😞', u'😖', u'😔', u'😓', u'😒']
+}
+
+
+def get_polarity(text, dictionaries=[emoticons, emojis]):
+    polarity = 'marl:Neutral'
+    print('Input for get_polarity', text)
+    for dictionary in dictionaries:
+        for label, values in dictionary.items():
+            for emoticon in values:
+                if emoticon and emoticon in text:
+                    polarity = label
+                    break
+    print('Polarity', polarity)
+    return polarity

example-plugins/basic_analyse_entry_plugin.py

@@ -0,0 +1,47 @@
+#!/usr/local/bin/python
+# -*- coding: utf-8 -*-
+
+from senpy import easy_test, models, plugins
+
+import basic
+
+
+class BasicAnalyseEntry(plugins.SentimentPlugin):
+    '''Equivalent to Basic, implementing the analyse_entry method'''
+
+    author = '@balkian'
+    version = '0.1'
+
+    mappings = {
+        'pos': 'marl:Positive',
+        'neg': 'marl:Negative',
+        'default': 'marl:Neutral'
+    }
+
+    def analyse_entry(self, entry, activity):
+        polarity = basic.get_polarity(entry.text)
+
+        polarity = self.mappings.get(polarity, self.mappings['default'])
+
+        s = models.Sentiment(marl__hasPolarity=polarity)
+        s.prov(activity)
+        entry.sentiments.append(s)
+        yield entry
+
+    test_cases = [{
+        'input': 'Hello :)',
+        'polarity': 'marl:Positive'
+    }, {
+        'input': 'So sad :(',
+        'polarity': 'marl:Negative'
+    }, {
+        'input': 'Yay! Emojis  😁',
+        'polarity': 'marl:Positive'
+    }, {
+        'input': 'But no emoticons 😢',
+        'polarity': 'marl:Negative'
+    }]
+
+
+if __name__ == '__main__':
+    easy_test()

example-plugins/basic_box_plugin.py

@@ -0,0 +1,39 @@
+#!/usr/local/bin/python
+# -*- coding: utf-8 -*-
+
+from senpy import easy_test, SentimentBox
+
+import basic
+
+
+class BasicBox(SentimentBox):
+    ''' A modified version of Basic that also does converts annotations manually'''
+
+    author = '@balkian'
+    version = '0.1'
+
+    def predict_one(self, features, **kwargs):
+        output = basic.get_polarity(features[0])
+        if output == 'pos':
+            return [1, 0, 0]
+        if output == 'neg':
+            return [0, 0, 1]
+        return [0, 1, 0]
+
+    test_cases = [{
+        'input': 'Hello :)',
+        'polarity': 'marl:Positive'
+    }, {
+        'input': 'So sad :(',
+        'polarity': 'marl:Negative'
+    }, {
+        'input': 'Yay! Emojis  😁',
+        'polarity': 'marl:Positive'
+    }, {
+        'input': 'But no emoticons 😢',
+        'polarity': 'marl:Negative'
+    }]
+
+
+if __name__ == '__main__':
+    easy_test()

example-plugins/basic_plugin.py

@@ -0,0 +1,39 @@
+#!/usr/local/bin/python
+# -*- coding: utf-8 -*-
+
+from senpy import easy_test, SentimentBox
+
+import basic
+
+
+class Basic(SentimentBox):
+    '''Provides sentiment annotation using a lexicon'''
+
+    author = '@balkian'
+    version = '0.1'
+
+    def predict_one(self, features, **kwargs):
+        output = basic.get_polarity(features[0])
+        if output == 'pos':
+            return [1, 0, 0]
+        if output == 'neu':
+            return [0, 1, 0]
+        return [0, 0, 1]
+
+    test_cases = [{
+        'input': u'Hello :)',
+        'polarity': 'marl:Positive'
+    }, {
+        'input': u'So sad :(',
+        'polarity': 'marl:Negative'
+    }, {
+        'input': u'Yay! Emojis  😁',
+        'polarity': 'marl:Positive'
+    }, {
+        'input': u'But no emoticons 😢',
+        'polarity': 'marl:Negative'
+    }]
+
+
+if __name__ == '__main__':
+    easy_test()

example-plugins/configurable_plugin.py

@@ -0,0 +1,105 @@
+#!/usr/local/bin/python
+# -*- coding: utf-8 -*-
+
+from senpy import easy_test, models, plugins
+
+import basic
+
+
+class Dictionary(plugins.SentimentPlugin):
+    '''Sentiment annotation using a configurable lexicon'''
+
+    author = '@balkian'
+    version = '0.2'
+
+    dictionaries = [basic.emojis, basic.emoticons]
+
+    mappings = {'pos': 'marl:Positive', 'neg': 'marl:Negative'}
+
+    def analyse_entry(self, entry, *args, **kwargs):
+        polarity = basic.get_polarity(entry.text, self.dictionaries)
+        if polarity in self.mappings:
+            polarity = self.mappings[polarity]
+
+        s = models.Sentiment(marl__hasPolarity=polarity)
+        s.prov(self)
+        entry.sentiments.append(s)
+        yield entry
+
+    test_cases = [{
+        'input': 'Hello :)',
+        'polarity': 'marl:Positive'
+    }, {
+        'input': 'So sad :(',
+        'polarity': 'marl:Negative'
+    }, {
+        'input': 'Yay! Emojis  😁',
+        'polarity': 'marl:Positive'
+    }, {
+        'input': 'But no emoticons 😢',
+        'polarity': 'marl:Negative'
+    }]
+
+
+class EmojiOnly(Dictionary):
+    '''Sentiment annotation with a basic lexicon of emojis'''
+    dictionaries = [basic.emojis]
+
+    test_cases = [{
+        'input': 'Hello :)',
+        'polarity': 'marl:Neutral'
+    }, {
+        'input': 'So sad :(',
+        'polarity': 'marl:Neutral'
+    }, {
+        'input': 'Yay! Emojis  😁',
+        'polarity': 'marl:Positive'
+    }, {
+        'input': 'But no emoticons 😢',
+        'polarity': 'marl:Negative'
+    }]
+
+
+class EmoticonsOnly(Dictionary):
+    '''Sentiment annotation with a basic lexicon of emoticons'''
+    dictionaries = [basic.emoticons]
+
+    test_cases = [{
+        'input': 'Hello :)',
+        'polarity': 'marl:Positive'
+    }, {
+        'input': 'So sad :(',
+        'polarity': 'marl:Negative'
+    }, {
+        'input': 'Yay! Emojis  😁',
+        'polarity': 'marl:Neutral'
+    }, {
+        'input': 'But no emoticons 😢',
+        'polarity': 'marl:Neutral'
+    }]
+
+
+class Salutes(Dictionary):
+    '''Sentiment annotation with a custom lexicon, for illustration purposes'''
+    dictionaries = [{
+        'marl:Positive': ['Hello', '!'],
+        'marl:Negative': ['Good bye', ]
+    }]
+
+    test_cases = [{
+        'input': 'Hello :)',
+        'polarity': 'marl:Positive'
+    }, {
+        'input': 'Good bye :(',
+        'polarity': 'marl:Negative'
+    }, {
+        'input': 'Yay! Emojis  😁',
+        'polarity': 'marl:Positive'
+    }, {
+        'input': 'But no emoticons 😢',
+        'polarity': 'marl:Neutral'
+    }]
+
+
+if __name__ == '__main__':
+    easy_test()

example-plugins/dummy_plugin.py

@@ -0,0 +1,25 @@
+from senpy import AnalysisPlugin, easy
+
+
+class Dummy(AnalysisPlugin):
+    '''This is a dummy self-contained plugin'''
+    author = '@balkian'
+    version = '0.1'
+
+    def analyse_entry(self, entry, params):
+        entry['nif:isString'] = entry['nif:isString'][::-1]
+        entry.reversed = entry.get('reversed', 0) + 1
+        yield entry
+
+    test_cases = [{
+        'entry': {
+            'nif:isString': 'Hello',
+        },
+        'expected': {
+            'nif:isString': 'olleH'
+        }
+    }]
+
+
+if __name__ == '__main__':
+    easy()

example-plugins/dummy_required_plugin.py

@@ -0,0 +1,40 @@
+from senpy import AnalysisPlugin, easy
+
+
+class DummyRequired(AnalysisPlugin):
+    '''This is a dummy self-contained plugin'''
+    author = '@balkian'
+    version = '0.1'
+    extra_params = {
+        'example': {
+            'description': 'An example parameter',
+            'required': True,
+            'options': ['a', 'b']
+        }
+    }
+
+    def analyse_entry(self, entry, params):
+        entry['nif:isString'] = entry['nif:isString'][::-1]
+        entry.reversed = entry.get('reversed', 0) + 1
+        yield entry
+
+    test_cases = [{
+        'entry': {
+            'nif:isString': 'Hello',
+        },
+        'should_fail': True
+    }, {
+        'entry': {
+            'nif:isString': 'Hello',
+        },
+        'params': {
+            'example': 'a'
+        },
+        'expected': {
+            'nif:isString': 'olleH'
+        }
+    }]
+
+
+if __name__ == '__main__':
+    easy()

example-plugins/emorand_plugin.py

@@ -4,8 +4,15 @@ from senpy.plugins import EmotionPlugin
 from senpy.models import EmotionSet, Emotion, Entry
 
 
-class RmoRandPlugin(EmotionPlugin):
-    def analyse_entry(self, entry, params):
+class EmoRand(EmotionPlugin):
+    '''A sample plugin that returns a random emotion annotation'''
+    name = 'emotion-random'
+    author = '@balkian'
+    version = '0.1'
+    url = "https://github.com/gsi-upm/senpy-plugins-community"
+    onyx__usesEmotionModel = "emoml:big6"
+
+    def analyse_entry(self, entry, activity):
         category = "emoml:big6happiness"
         number = max(-1, min(1, random.gauss(0, 0.5)))
         if number > 0:
@@ -13,7 +20,7 @@ class RmoRandPlugin(EmotionPlugin):
         emotionSet = EmotionSet()
         emotion = Emotion({"onyx:hasEmotionCategory": category})
         emotionSet.onyx__hasEmotion.append(emotion)
-        emotionSet.prov__wasGeneratedBy = self.id
+        emotionSet.prov(activity)
         entry.emotions.append(emotionSet)
         yield entry
 
@@ -21,6 +28,6 @@ class RmoRandPlugin(EmotionPlugin):
         params = dict()
         results = list()
         for i in range(100):
-            res = next(self.analyse_entry(Entry(nif__isString="Hello"), params))
+            res = next(self.analyse_entry(Entry(nif__isString="Hello"), self.activity(params)))
             res.validate()
             results.append(res.emotions[0]['onyx:hasEmotion'][0]['onyx:hasEmotionCategory'])

example-plugins/mynoop.py

@@ -0,0 +1,24 @@
+import noop
+from senpy.plugins import SentimentPlugin
+
+
+class NoOp(SentimentPlugin):
+    '''This plugin does nothing. Literally nothing.'''
+
+    version = 0
+
+    def analyse_entry(self, entry, *args, **kwargs):
+        yield entry
+
+    def test(self):
+        print(dir(noop))
+        super(NoOp, self).test()
+
+    test_cases = [{
+        'entry': {
+            'nif:isString': 'hello'
+        },
+        'expected': {
+            'nif:isString': 'hello'
+        }
+    }]

example-plugins/mynoop.senpy

@@ -0,0 +1,3 @@
+module: mynoop
+requirements:
+ - noop

example-plugins/parameterized_plugin.py

@@ -0,0 +1,64 @@
+#!/usr/local/bin/python
+# -*- coding: utf-8 -*-
+
+from senpy import easy_test, models, plugins
+
+import basic
+
+
+class ParameterizedDictionary(plugins.SentimentPlugin):
+    '''This is a basic self-contained plugin'''
+
+    author = '@balkian'
+    version = '0.2'
+
+    extra_params = {
+        'positive-words': {
+            'description': 'Comma-separated list of words that are considered positive',
+            'aliases': ['positive'],
+            'required': True
+        },
+        'negative-words': {
+            'description': 'Comma-separated list of words that are considered negative',
+            'aliases': ['negative'],
+            'required': False
+        }
+    }
+
+    def analyse_entry(self, entry, activity):
+        params = activity.params
+        positive_words = params['positive-words'].split(',')
+        negative_words = params['negative-words'].split(',')
+        dictionary = {
+            'marl:Positive': positive_words,
+            'marl:Negative': negative_words,
+        }
+        polarity = basic.get_polarity(entry.text, [dictionary])
+
+        s = models.Sentiment(marl__hasPolarity=polarity)
+        s.prov(activity)
+        entry.sentiments.append(s)
+        yield entry
+
+    test_cases = [
+        {
+            'input': 'Hello :)',
+            'polarity': 'marl:Positive',
+            'parameters': {
+                'positive': "Hello,:)",
+                'negative': "sad,:()"
+            }
+        },
+        {
+            'input': 'Hello :)',
+            'polarity': 'marl:Negative',
+            'parameters': {
+                'positive': "",
+                'negative': "Hello"
+            }
+        }
+    ]
+
+
+if __name__ == '__main__':
+    easy_test()

example-plugins/rand_plugin.py

@@ -0,0 +1,38 @@
+import random
+from senpy import SentimentPlugin, Sentiment, Entry
+
+
+class RandSent(SentimentPlugin):
+    '''A sample plugin that returns a random sentiment annotation'''
+    name = 'sentiment-random'
+    author = "@balkian"
+    version = '0.1'
+    url = "https://github.com/gsi-upm/senpy-plugins-community"
+    marl__maxPolarityValue = '1'
+    marl__minPolarityValue = "-1"
+
+    def analyse_entry(self, entry, activity):
+        polarity_value = max(-1, min(1, random.gauss(0.2, 0.2)))
+        polarity = "marl:Neutral"
+        if polarity_value > 0:
+            polarity = "marl:Positive"
+        elif polarity_value < 0:
+            polarity = "marl:Negative"
+        sentiment = Sentiment(marl__hasPolarity=polarity,
+                              marl__polarityValue=polarity_value)
+        sentiment.prov(activity)
+        entry.sentiments.append(sentiment)
+        yield entry
+
+    def test(self):
+        '''Run several random analyses.'''
+        params = dict()
+        results = list()
+        for i in range(50):
+            activity = self.activity(params)
+            res = next(self.analyse_entry(Entry(nif__isString="Hello"),
+                                          activity))
+            res.validate()
+            results.append(res.sentiments[0]['marl:hasPolarity'])
+        assert 'marl:Positive' in results
+        assert 'marl:Negative' in results

example-plugins/sklearn/mydata.py

@@ -0,0 +1,33 @@
+'''
+Create a dummy dataset.
+Messages with a happy emoticon are labelled positive
+Messages with a sad emoticon are labelled negative
+'''
+import random
+
+dataset = []
+
+vocabulary = ['hello', 'world', 'senpy', 'cool', 'goodbye', 'random', 'text']
+
+emojimap = {
+    1: [':)', ],
+    -1: [':(', ]
+}
+
+
+for tag, values in emojimap.items():
+    for i in range(1000):
+        msg = ''
+        for j in range(3):
+            msg += random.choice(vocabulary)
+            msg += " "
+        msg += random.choice(values)
+        dataset.append([msg, tag])
+
+
+text = []
+labels = []
+
+for i in dataset:
+    text.append(i[0])
+    labels.append(i[1])

example-plugins/sklearn/mypipeline.py

@@ -0,0 +1,30 @@
+from sklearn.pipeline import Pipeline
+from sklearn.feature_extraction.text import CountVectorizer
+from sklearn.model_selection import train_test_split
+
+from mydata import text, labels
+
+X_train, X_test, y_train, y_test = train_test_split(text, labels, test_size=0.12, random_state=42)
+
+from sklearn.naive_bayes import MultinomialNB
+
+
+count_vec = CountVectorizer(tokenizer=lambda x: x.split())
+clf3 = MultinomialNB()
+pipeline = Pipeline([('cv', count_vec),
+                    ('clf', clf3)])
+
+pipeline.fit(X_train, y_train)
+print('Feature names: {}'.format(count_vec.get_feature_names()))
+print('Class count: {}'.format(clf3.class_count_))
+
+
+if __name__ == '__main__':
+    print('--Results--')
+    tests = [
+        (['The sentiment for senpy should be positive :)', ], 1),
+        (['The sentiment for anything else should be negative :()', ], -1)
+    ]
+    for features, expected in tests:
+        result = pipeline.predict(features)
+        print('Input: {}\nExpected: {}\nGot: {}'.format(features[0], expected, result))

example-plugins/sklearn/pipeline_plugin.py

@@ -0,0 +1,32 @@
+from senpy import SentimentBox, easy_test
+
+from mypipeline import pipeline
+
+
+class PipelineSentiment(SentimentBox):
+    '''This is a pipeline plugin that wraps a classifier defined in another module
+(mypipeline).'''
+    author = '@balkian'
+    version = 0.1
+    maxPolarityValue = 1
+    minPolarityValue = -1
+
+    def predict_one(self, features, **kwargs):
+        if pipeline.predict(features) > 0:
+            return [1, 0, 0]
+        return [0, 0, 1]
+
+    test_cases = [
+        {
+            'input': 'The sentiment for senpy should be positive :)',
+            'polarity': 'marl:Positive'
+        },
+        {
+            'input': 'The sentiment for senpy should be negative :(',
+            'polarity': 'marl:Negative'
+        }
+    ]
+
+
+if __name__ == '__main__':
+    easy_test()

example-plugins/sleep_plugin.py

@@ -0,0 +1,27 @@
+from senpy.plugins import AnalysisPlugin
+from time import sleep
+
+
+class Sleep(AnalysisPlugin):
+    '''Dummy plugin to test async'''
+    author = "@balkian"
+    version = "0.2"
+    timeout = 0.05
+    extra_params = {
+        "timeout": {
+            "@id": "timeout_sleep",
+            "aliases": ["timeout", "to"],
+            "required": False,
+            "default": 0
+        }
+    }
+
+    def activate(self, *args, **kwargs):
+        sleep(self.timeout)
+
+    def analyse_entry(self, entry, params):
+        sleep(float(params.get("timeout", self.timeout)))
+        yield entry
+
+    def test(self):
+        pass

extra-requirements.txt

@@ -0,0 +1 @@
+gsitk>0.1.9.1

k8s/senpy-deployment.yaml

@@ -13,10 +13,8 @@ spec:
     spec:
       containers:
       - name: senpy-latest
-        image: gsiupm/senpy:latest
+        image: $IMAGEWTAG
         imagePullPolicy: Always
-        args:
-          - "--default-plugins"
         resources:
           limits:
             memory: "512Mi"

k8s/senpy-ingress.yaml

@@ -12,3 +12,10 @@ spec:
         backend:
           serviceName: senpy-latest
           servicePort: 5000
+  - host: latest.senpy.gsi.upm.es
+    http:
+      paths:
+      - path: /
+        backend:
+          serviceName: senpy-latest
+          servicePort: 5000

requirements.txt

@@ -3,10 +3,14 @@ requests>=2.4.1
 tornado>=4.4.3
 PyLD>=0.6.5
 nltk
-six
 future
 jsonschema
 jsonref
 PyYAML
 rdflib
 rdflib-jsonld
+numpy
+scipy
+scikit-learn>=0.20
+responses
+jmespath

senpy/__init__.py

@@ -25,4 +25,10 @@ logger = logging.getLogger(__name__)
 
 logger.info('Using senpy version: {}'.format(__version__))
 
+from .utils import easy, easy_load, easy_test  # noqa: F401
+
+from .models import *  # noqa: F401,F403
+from .plugins import *  # noqa: F401,F403
+from .extensions import *  # noqa: F401,F403
+
 __all__ = ['api', 'blueprints', 'cli', 'extensions', 'models', 'plugins']

senpy/__main__.py

@@ -22,6 +22,7 @@ the server.
 
 from flask import Flask
 from senpy.extensions import Senpy
+from senpy.utils import easy_test
 
 import logging
 import os
@@ -41,6 +42,12 @@ def main():
         type=str,
         default="INFO",
         help='Logging level')
+    parser.add_argument(
+        '--log-format',
+        metavar='log_format',
+        type=str,
+        default='%(asctime)s %(levelname)-10s %(name)-30s \t %(message)s',
+        help='Logging format')
     parser.add_argument(
         '--debug',
         '-d',
@@ -48,10 +55,10 @@ def main():
         default=False,
         help='Run the application in debug mode')
     parser.add_argument(
-        '--default-plugins',
+        '--no-default-plugins',
         action='store_true',
         default=False,
-        help='Load the default plugins')
+        help='Do not load the default plugins')
     parser.add_argument(
         '--host',
         type=str,
@@ -67,7 +74,7 @@ def main():
         '--plugins-folder',
         '-f',
         type=str,
-        default='plugins',
+        action='append',
         help='Where to look for plugins.')
     parser.add_argument(
         '--only-install',
@@ -75,6 +82,23 @@ def main():
         action='store_true',
         default=False,
         help='Do not run a server, only install plugin dependencies')
+    parser.add_argument(
+        '--only-test',
+        action='store_true',
+        default=False,
+        help='Do not run a server, just test all plugins')
+    parser.add_argument(
+        '--test',
+        '-t',
+        action='store_true',
+        default=False,
+        help='Test all plugins before launching the server')
+    parser.add_argument(
+        '--only-list',
+        '--list',
+        action='store_true',
+        default=False,
+        help='Do not run a server, only list plugins found')
     parser.add_argument(
         '--data-folder',
         '--data',
@@ -82,40 +106,85 @@ def main():
         default=None,
         help='Where to look for data. It be set with the SENPY_DATA environment variable as well.')
     parser.add_argument(
-        '--threaded',
-        action='store_false',
-        default=True,
-        help='Run a threaded server')
+        '--no-threaded',
+        action='store_true',
+        default=False,
+        help='Run a single-threaded server')
+    parser.add_argument(
+        '--no-deps',
+        '-n',
+        action='store_true',
+        default=False,
+        help='Skip installing dependencies')
     parser.add_argument(
         '--version',
         '-v',
         action='store_true',
         default=False,
         help='Output the senpy version and exit')
+    parser.add_argument(
+        '--allow-fail',
+        '--fail',
+        action='store_true',
+        default=False,
+        help='Do not exit if some plugins fail to activate')
     args = parser.parse_args()
+    print('Senpy version {}'.format(senpy.__version__))
+    print(sys.version)
     if args.version:
-        print('Senpy version {}'.format(senpy.__version__))
-        print(sys.version)
         exit(1)
-    logging.basicConfig()
     rl = logging.getLogger()
     rl.setLevel(getattr(logging, args.level))
+    logger_handler = rl.handlers[0]
+
+    # First, generic formatter:
+    logger_handler.setFormatter(logging.Formatter(args.log_format))
+
     app = Flask(__name__)
     app.debug = args.debug
-    sp = Senpy(app, args.plugins_folder,
-               default_plugins=args.default_plugins,
+    sp = Senpy(app,
+               plugin_folder=None,
+               default_plugins=not args.no_default_plugins,
                data_folder=args.data_folder)
-    sp.install_deps()
+    folders = list(args.plugins_folder) if args.plugins_folder else []
+    if not folders:
+        folders.append(".")
+    for p in folders:
+        sp.add_folder(p)
+
+    plugins = sp.plugins(plugin_type=None, is_activated=False)
+    maxname = max(len(x.name) for x in plugins)
+    maxversion = max(len(str(x.version)) for x in plugins)
+    print('Found {} plugins:'.format(len(plugins)))
+    for plugin in plugins:
+        import inspect
+        fpath = inspect.getfile(plugin.__class__)
+        print('\t{: <{maxname}} @ {: <{maxversion}} -> {}'.format(plugin.name,
+                                                                  plugin.version,
+                                                                  fpath,
+                                                                  maxname=maxname,
+                                                                  maxversion=maxversion))
+    if args.only_list:
+        return
+    if not args.no_deps:
+        sp.install_deps()
     if args.only_install:
         return
-    sp.activate_all()
+    sp.activate_all(allow_fail=args.allow_fail)
+    if args.test or args.only_test:
+        easy_test(sp.plugins(), debug=args.debug)
+        if args.only_test:
+            return
     print('Senpy version {}'.format(senpy.__version__))
     print('Server running on port %s:%d. Ctrl+C to quit' % (args.host,
                                                             args.port))
-    app.run(args.host,
-            args.port,
-            threaded=args.threaded,
-            debug=app.debug)
+    try:
+        app.run(args.host,
+                args.port,
+                threaded=not args.no_threaded,
+                debug=app.debug)
+    except KeyboardInterrupt:
+        print('Bye!')
     sp.deactivate_all()
 
 

senpy/api.py

@@ -3,74 +3,190 @@ from .models import Error, Results, Entry, from_string
 import logging
 logger = logging.getLogger(__name__)
 
+boolean = [True, False]
+
+processors = {
+    'string_to_tuple': lambda p: p if isinstance(p, (tuple, list)) else tuple(p.split(','))
+}
+
 API_PARAMS = {
     "algorithm": {
         "aliases": ["algorithms", "a", "algo"],
-        "required": False,
+        "required": True,
+        "default": 'default',
+        "processor": 'string_to_tuple',
         "description": ("Algorithms that will be used to process the request."
                         "It may be a list of comma-separated names."),
     },
     "expanded-jsonld": {
         "@id": "expanded-jsonld",
-        "aliases": ["expanded"],
+        "description": "use JSON-LD expansion to get full URIs",
+        "aliases": ["expanded", "expanded_jsonld"],
+        "options": boolean,
         "required": True,
-        "default": 0
+        "default": False
     },
-    "with_parameters": {
+    "with-parameters": {
         "aliases": ['withparameters',
-                    'with-parameters'],
-        "options": "boolean",
+                    'with_parameters'],
+        "description": "include initial parameters in the response",
+        "options": boolean,
         "default": False,
         "required": True
     },
-    "plugin_type": {
-        "@id": "pluginType",
-        "description": 'What kind of plugins to list',
-        "aliases": ["pluginType"],
-        "required": True,
-        "default": "analysisPlugin"
-    },
     "outformat": {
         "@id": "outformat",
         "aliases": ["o"],
         "default": "json-ld",
+        "description": """The data can be semantically formatted (JSON-LD, turtle or n-triples),
+given as a list of comma-separated fields (see the fields option) or constructed from a Jinja2
+template (see the template option).""",
         "required": True,
-        "options": ["json-ld", "turtle"],
+        "options": ["json-ld", "turtle", "ntriples"],
+    },
+    "template": {
+        "@id": "template",
+        "required": False,
+        "description": """Jinja2 template for the result. The input data for the template will
+be the results as a dictionary.
+For example:
+
+Consider the results before templating:
+
+```
+[{
+    "@type": "entry",
+    "onyx:hasEmotionSet": [],
+    "nif:isString": "testing the template",
+    "marl:hasOpinion": [
+        {
+            "@type": "sentiment",
+            "marl:hasPolarity": "marl:Positive"
+        }
+    ]
+}]
+```
+
+
+And the template:
+
+```
+{% for entry in entries %}
+{{ entry["nif:isString"] | upper }},{{entry.sentiments[0]["marl:hasPolarity"].split(":")[1]}}
+{% endfor %}
+```
+
+The final result would be:
+
+```
+TESTING THE TEMPLATE,Positive
+```
+"""
+
+    },
+    "fields": {
+        "@id": "fields",
+        "required": False,
+        "description": """A jmespath selector, that can be used to extract a new dictionary, array or value
+from the results.
+jmespath is a powerful query language for json and/or dictionaries.
+It allows you to change the structure (and data) of your objects through queries.
+
+e.g., the following expression gets a list of `[emotion label, intensity]` for each entry:
+`entries[]."onyx:hasEmotionSet"[]."onyx:hasEmotion"[]["onyx:hasEmotionCategory","onyx:hasEmotionIntensity"]`
+
+For more information, see: https://jmespath.org
+
+"""
     },
     "help": {
         "@id": "help",
         "description": "Show additional help to know more about the possible parameters",
         "aliases": ["h"],
         "required": True,
-        "options": "boolean",
+        "options": boolean,
         "default": False
     },
-    "emotionModel": {
+    "verbose": {
+        "@id": "verbose",
+        "description": "Show all properties in the result",
+        "aliases": ["v"],
+        "required": True,
+        "options": boolean,
+        "default": False
+    },
+    "aliases": {
+        "@id": "aliases",
+        "description": "Replace JSON properties with their aliases",
+        "aliases": [],
+        "required": True,
+        "options": boolean,
+        "default": False
+    },
+    "emotion-model": {
         "@id": "emotionModel",
-        "aliases": ["emoModel"],
+        "description": """Emotion model to use in the response.
+Senpy will try to convert the output to this model automatically.
+
+Examples: `wna:liking` and `emoml:big6`.
+        """,
+        "aliases": ["emoModel", "emotionModel"],
         "required": False
     },
     "conversion": {
         "@id": "conversion",
-        "description": "How to show the elements that have (not) been converted",
+        "description": """How to show the elements that have (not) been converted.
+
+* full: converted and original elements will appear side-by-side
+* filtered: only converted elements will be shown
+* nested: converted elements will be shown, and they will include a link to the original element
+(using `prov:wasGeneratedBy`).
+""",
         "required": True,
         "options": ["filtered", "nested", "full"],
         "default": "full"
     }
 }
 
+EVAL_PARAMS = {
+    "algorithm": {
+        "aliases": ["plug", "p", "plugins", "algorithms", 'algo', 'a', 'plugin'],
+        "description": "Plugins to evaluate",
+        "required": True,
+        "help": "See activated plugins in /plugins",
+        "processor": API_PARAMS['algorithm']['processor']
+    },
+    "dataset": {
+        "aliases": ["datasets", "data", "d"],
+        "description": "Datasets to be evaluated",
+        "required": True,
+        "help": "See avalaible datasets in /datasets"
+    }
+}
+
+PLUGINS_PARAMS = {
+    "plugin-type": {
+        "@id": "pluginType",
+        "description": 'What kind of plugins to list',
+        "aliases": ["pluginType", "plugin_type"],
+        "required": True,
+        "default": 'analysisPlugin'
+    }
+}
+
 WEB_PARAMS = {
-    "inHeaders": {
-        "aliases": ["headers"],
+    "in-headers": {
+        "aliases": ["headers", "inheaders", "inHeaders", "in-headers", "in_headers"],
+        "description": "Only include the JSON-LD context in the headers",
         "required": True,
         "default": False,
-        "options": "boolean"
+        "options": boolean
     },
 }
 
 CLI_PARAMS = {
-    "plugin_folder": {
-        "aliases": ["folder"],
+    "plugin-folder": {
+        "aliases": ["folder", "plugin_folder"],
         "required": True,
         "default": "."
     },
@@ -85,6 +201,7 @@ NIF_PARAMS = {
     },
     "intype": {
         "@id": "intype",
+        "description": "input type",
         "aliases": ["t"],
         "required": False,
         "default": "direct",
@@ -92,31 +209,44 @@ NIF_PARAMS = {
     },
     "informat": {
         "@id": "informat",
+        "description": "input format",
         "aliases": ["f"],
         "required": False,
         "default": "text",
-        "options": ["turtle", "text", "json-ld"],
+        "options": ["text", "json-ld"],
     },
     "language": {
         "@id": "language",
+        "description": "language of the input",
         "aliases": ["l"],
         "required": False,
     },
     "prefix": {
         "@id": "prefix",
+        "description": "prefix to use for new entities",
         "aliases": ["p"],
         "required": True,
         "default": "",
     },
     "urischeme": {
         "@id": "urischeme",
+        "description": "scheme for NIF URIs",
         "aliases": ["u"],
         "required": False,
         "default": "RFC5147String",
-        "options": "RFC5147String"
+        "options": ["RFC5147String", ]
     }
 }
 
+BUILTIN_PARAMS = {}
+
+for d in [
+        NIF_PARAMS, CLI_PARAMS, WEB_PARAMS, PLUGINS_PARAMS, EVAL_PARAMS,
+        API_PARAMS
+]:
+    for k, v in d.items():
+        BUILTIN_PARAMS[k] = v
+
 
 def parse_params(indict, *specs):
     if not specs:
@@ -126,57 +256,154 @@ def parse_params(indict, *specs):
     wrong_params = {}
     for spec in specs:
         for param, options in iteritems(spec):
-            if param[0] != "@":  # Exclude json-ld properties
-                for alias in options.get("aliases", []):
-                    # Replace each alias with the correct name of the parameter
-                    if alias in indict and alias is not param:
-                        outdict[param] = indict[alias]
-                        del indict[alias]
-                        continue
-                if param not in outdict:
-                    if options.get("required", False) and "default" not in options:
-                        wrong_params[param] = spec[param]
-                    else:
-                        if "default" in options:
-                            outdict[param] = options["default"]
-                elif "options" in spec[param]:
-                    if spec[param]["options"] == "boolean":
-                        outdict[param] = outdict[param] in [None, True, 'true', '1']
-                    elif outdict[param] not in spec[param]["options"]:
-                        wrong_params[param] = spec[param]
+            for alias in options.get("aliases", []):
+                # Replace each alias with the correct name of the parameter
+                if alias in indict and alias != param:
+                    outdict[param] = indict[alias]
+                    del outdict[alias]
+                    break
+            if param not in outdict:
+                if "default" in options:
+                    # We assume the default is correct
+                    outdict[param] = options["default"]
+                elif options.get("required", False):
+                    wrong_params[param] = spec[param]
+                continue
+            if 'processor' in options:
+                outdict[param] = processors[options['processor']](outdict[param])
+            if "options" in options:
+                if options["options"] == boolean:
+                    outdict[param] = str(outdict[param]).lower() in ['true', '1', '']
+                elif outdict[param] not in options["options"]:
+                    wrong_params[param] = spec[param]
     if wrong_params:
         logger.debug("Error parsing: %s", wrong_params)
         message = Error(
             status=400,
-            message="Missing or invalid parameters",
+            message='Missing or invalid parameters',
             parameters=outdict,
-            errors={param: error
-                    for param, error in iteritems(wrong_params)})
+            errors=wrong_params)
         raise message
-    if 'algorithm' in outdict and not isinstance(outdict['algorithm'], list):
-        outdict['algorithm'] = outdict['algorithm'].split(',')
     return outdict
 
 
-def get_extra_params(request, plugin=None):
-    params = request.parameters.copy()
-    if plugin:
-        extra_params = parse_params(params, plugin.get('extra_params', {}))
-        params.update(extra_params)
+def get_all_params(plugins, *specs):
+    '''Return a list of parameters for a given set of specifications and plugins.'''
+    dic = {}
+    for s in specs:
+        dic.update(s)
+    dic.update(get_extra_params(plugins))
+    return dic
+
+
+def get_extra_params(plugins):
+    '''Get a list of possible parameters given a list of plugins'''
+    params = {}
+    extra_params = {}
+    for plugin in plugins:
+        this_params = plugin.get('extra_params', {})
+        for k, v in this_params.items():
+            if k not in extra_params:
+                extra_params[k] = {}
+            extra_params[k][plugin.name] = v
+    for k, v in extra_params.items():  # Resolve conflicts
+        if len(v) == 1:  # Add the extra options that do not collide
+            params[k] = list(v.values())[0]
+        else:
+            required = False
+            aliases = None
+            options = None
+            default = None
+            nodefault = False  # Set when defaults are not compatible
+
+            for plugin, opt in v.items():
+                params['{}.{}'.format(plugin, k)] = opt
+                required = required or opt.get('required', False)
+                newaliases = set(opt.get('aliases', []))
+                if aliases is None:
+                    aliases = newaliases
+                else:
+                    aliases = aliases & newaliases
+                if 'options' in opt:
+                    newoptions = set(opt['options'])
+                    options = newoptions if options is None else options & newoptions
+                if 'default' in opt:
+                    newdefault = opt['default']
+                    if newdefault:
+                        if default is None and not nodefault:
+                            default = newdefault
+                        elif newdefault != default:
+                            nodefault = True
+                            default = None
+            # Check for incompatibilities
+            if options != set():
+                params[k] = {
+                    'default': default,
+                    'aliases': list(aliases),
+                    'required': required,
+                    'options': list(options)
+                }
     return params
 
 
+def parse_analyses(params, plugins):
+    '''
+    Parse the given parameters individually for each plugin, and get a list of the parameters that
+    belong to each of the plugins. Each item can then be used in the plugin.analyse_entries method.
+    '''
+    analysis_list = []
+    for i, plugin in enumerate(plugins):
+        if not plugin:
+            continue
+        this_params = filter_params(params, plugin, i)
+        parsed = parse_params(this_params, plugin.get('extra_params', {}))
+        analysis = plugin.activity(parsed)
+        analysis_list.append(analysis)
+    return analysis_list
+
+
+def filter_params(params, plugin, ith=-1):
+    '''
+    Get the values within params that apply to a plugin.
+    More specific names override more general names, in this order:
+
+    <index_order>.parameter > <plugin.name>.parameter > parameter
+
+
+    Example:
+
+    >>> filter_params({'0.hello': True, 'hello': False}, Plugin(), 0)
+    { '0.hello': True, 'hello': True}
+
+    '''
+    thisparams = {}
+    if ith >= 0:
+        ith = '{}.'.format(ith)
+    else:
+        ith = ""
+    for k, v in params.items():
+        if ith and k.startswith(str(ith)):
+            thisparams[k[len(ith):]] = v
+        elif k.startswith(plugin.name):
+            thisparams[k[len(plugin.name) + 1:]] = v
+        elif k not in thisparams:
+            thisparams[k] = v
+    return thisparams
+
+
 def parse_call(params):
-    '''Return a results object based on the parameters used in a call/request.
+    '''
+    Return a results object based on the parameters used in a call/request.
     '''
     params = parse_params(params, NIF_PARAMS)
     if params['informat'] == 'text':
         results = Results()
-        entry = Entry(nif__isString=params['input'])
+        entry = Entry(nif__isString=params['input'], id='prefix:')  # Use @base
         results.entries.append(entry)
     elif params['informat'] == 'json-ld':
         results = from_string(params['input'], cls=Results)
-    else:
-        raise NotImplemented('Informat {} is not implemented'.format(params['informat']))
+    else:  # pragma: no cover
+        raise NotImplementedError('Informat {} is not implemented'.format(
+            params['informat']))
     results.parameters = params
     return results

senpy/blueprints.py

@@ -18,21 +18,42 @@
 Blueprints for Senpy
 """
 from flask import (Blueprint, request, current_app, render_template, url_for,
-                   jsonify)
-from .models import Error, Response, Help, Plugins, read_schema
+                   jsonify, redirect)
+from .models import Error, Response, Help, Plugins, read_schema, dump_schema, Datasets
 from . import api
 from .version import __version__
 from functools import wraps
 
+from .gsitk_compat import GSITK_AVAILABLE
+
 import logging
 import json
+import base64
 
 logger = logging.getLogger(__name__)
 
 api_blueprint = Blueprint("api", __name__)
-demo_blueprint = Blueprint("demo", __name__)
+demo_blueprint = Blueprint("demo", __name__, template_folder='templates')
 ns_blueprint = Blueprint("ns", __name__)
 
+_mimetypes_r = {'json-ld': ['application/ld+json'],
+                'turtle': ['text/turtle'],
+                'ntriples': ['application/n-triples'],
+                'text': ['text/plain']}
+
+MIMETYPES = {}
+
+for k, vs in _mimetypes_r.items():
+    for v in vs:
+        if v in MIMETYPES:
+            raise Exception('MIMETYPE {} specified for two formats: {} and {}'.format(v,
+                                                                                      v,
+                                                                                      MIMETYPES[v]))
+        MIMETYPES[v] = k
+
+DEFAULT_MIMETYPE = 'application/ld+json'
+DEFAULT_FORMAT = 'json-ld'
+
 
 def get_params(req):
     if req.method == 'POST':
@@ -44,83 +65,190 @@ def get_params(req):
     return indict
 
 
+def encode_url(url=None):
+    code = ''
+    if not url:
+        url = request.parameters.get('prefix', request.full_path[1:] + '#')
+    return code or base64.urlsafe_b64encode(url.encode()).decode()
+
+
+def url_for_code(code, base=None):
+    # if base:
+    #     return base + code
+    # return url_for('api.decode', code=code, _external=True)
+    # This was producing unique yet very long URIs, which wasn't ideal for visualization.
+    return 'http://senpy.invalid/'
+
+
+def decoded_url(code, base=None):
+    path = base64.urlsafe_b64decode(code.encode()).decode()
+    if path[:4] == 'http':
+        return path
+    base = base or request.url_root
+    return base + path
+
+
 @demo_blueprint.route('/')
 def index():
-    return render_template("index.html", version=__version__)
+    # ev = str(get_params(request).get('evaluation', True))
+    # evaluation_enabled = ev.lower() not in ['false', 'no', 'none']
+    evaluation_enabled = GSITK_AVAILABLE
+
+    return render_template("index.html",
+                           evaluation=evaluation_enabled,
+                           version=__version__)
 
 
-@api_blueprint.route('/contexts/<entity>.jsonld')
-def context(entity="context"):
+@api_blueprint.route('/contexts/<code>')
+def context(code=''):
     context = Response._context
-    context['@vocab'] = url_for('ns.index', _external=True)
+    context['@base'] = url_for('api.decode', code=code, _external=True)
+    context['endpoint'] = url_for('api.api_root', _external=True)
     return jsonify({"@context": context})
 
 
+@api_blueprint.route('/d/<code>')
+def decode(code):
+    try:
+        return redirect(decoded_url(code))
+    except Exception:
+        return Error('invalid URL').flask()
+
+
 @ns_blueprint.route('/')  # noqa: F811
 def index():
-    context = Response._context
-    context['@vocab'] = url_for('.ns', _external=True)
+    context = Response._context.copy()
+    context['endpoint'] = url_for('api.api_root', _external=True)
     return jsonify({"@context": context})
 
 
 @api_blueprint.route('/schemas/<schema>')
 def schema(schema="definitions"):
     try:
-        return jsonify(read_schema(schema))
-    except Exception:  # Should be FileNotFoundError, but it's missing from py2
-        return Error(message="Schema not found", status=404).flask()
+        return dump_schema(read_schema(schema))
+    except Exception as ex:  # Should be FileNotFoundError, but it's missing from py2
+        return Error(message="Schema not found: {}".format(ex), status=404).flask()
 
 
 def basic_api(f):
+    default_params = {
+        'in-headers': False,
+        'expanded-jsonld': False,
+        'outformat': None,
+        'with-parameters': True,
+    }
+
     @wraps(f)
     def decorated_function(*args, **kwargs):
         raw_params = get_params(request)
+        # logger.info('Getting request: {}'.format(raw_params))
+        logger.debug('Getting request. Params: {}'.format(raw_params))
         headers = {'X-ORIGINAL-PARAMS': json.dumps(raw_params)}
+        params = default_params
+
+        mime = request.accept_mimetypes\
+                      .best_match(MIMETYPES.keys(),
+                                  DEFAULT_MIMETYPE)
+
+        mimeformat = MIMETYPES.get(mime, DEFAULT_FORMAT)
+        outformat = mimeformat
 
-        outformat = 'json-ld'
         try:
-            print('Getting request:')
-            print(request)
             params = api.parse_params(raw_params, api.WEB_PARAMS, api.API_PARAMS)
+            outformat = params.get('outformat', mimeformat)
             if hasattr(request, 'parameters'):
                 request.parameters.update(params)
             else:
                 request.parameters = params
             response = f(*args, **kwargs)
-        except Error as ex:
-            response = ex
-            response.parameters = params
-            logger.error(ex)
-            if current_app.debug:
+
+            if 'parameters' in response and not params['with-parameters']:
+                del response.parameters
+
+            logger.debug('Response: {}'.format(response))
+
+            prefix = params.get('prefix')
+            code = encode_url(prefix)
+
+            return response.flask(
+                in_headers=params['in-headers'],
+                headers=headers,
+                prefix=prefix or url_for_code(code),
+                base=prefix,
+                context_uri=url_for('api.context',
+                                    code=code,
+                                    _external=True),
+                outformat=outformat,
+                expanded=params['expanded-jsonld'],
+                template=params.get('template'),
+                verbose=params['verbose'],
+                aliases=params['aliases'],
+                fields=params.get('fields'))
+
+        except (Exception) as ex:
+            if current_app.debug or current_app.config['TESTING']:
                 raise
-
-        in_headers = params['inHeaders']
-        expanded = params['expanded-jsonld']
-        outformat = params['outformat']
-
-        return response.flask(
-            in_headers=in_headers,
-            headers=headers,
-            prefix=url_for('.api_root', _external=True),
-            context_uri=url_for('api.context',
-                                entity=type(response).__name__,
-                                _external=True),
-            outformat=outformat,
-            expanded=expanded)
+            if not isinstance(ex, Error):
+                msg = "{}".format(ex)
+                ex = Error(message=msg, status=500)
+            response = ex
+            response.parameters = raw_params
+            logger.exception(ex)
+            return response.flask(
+                outformat=outformat,
+                expanded=params['expanded-jsonld'],
+                verbose=params.get('verbose', True),
+            )
 
     return decorated_function
 
 
-@api_blueprint.route('/', methods=['POST', 'GET'])
+@api_blueprint.route('/', defaults={'plugins': None}, methods=['POST', 'GET'])
+@api_blueprint.route('/<path:plugins>', methods=['POST', 'GET'])
 @basic_api
-def api_root():
+def api_root(plugins):
+    if plugins:
+        if request.parameters['algorithm'] != api.API_PARAMS['algorithm']['default']:
+            raise Error('You cannot specify the algorithm with a parameter and a URL variable.'
+                        ' Please, remove one of them')
+        plugins = plugins.replace('+', ',').replace('/', ',')
+        plugins = api.processors['string_to_tuple'](plugins)
+    else:
+        plugins = request.parameters['algorithm']
+
+    print(plugins)
+
+    sp = current_app.senpy
+    plugins = sp.get_plugins(plugins)
+
     if request.parameters['help']:
-        dic = dict(api.API_PARAMS, **api.NIF_PARAMS)
+        apis = [api.WEB_PARAMS, api.API_PARAMS, api.NIF_PARAMS]
+        # Verbose is set to False as default, but we want it to default to
+        # True for help. This checks the original value, to make sure it wasn't
+        # set by default.
+        if not request.parameters['verbose'] and get_params(request).get('verbose'):
+            apis = []
+        if request.parameters['algorithm'] == ['default', ]:
+            plugins = []
+        allparameters = api.get_all_params(plugins, *apis)
+        response = Help(valid_parameters=allparameters)
+        return response
+    req = api.parse_call(request.parameters)
+    analyses = api.parse_analyses(req.parameters, plugins)
+    results = current_app.senpy.analyse(req, analyses)
+    return results
+
+
+@api_blueprint.route('/evaluate/', methods=['POST', 'GET'])
+@basic_api
+def evaluate():
+    if request.parameters['help']:
+        dic = dict(api.EVAL_PARAMS)
         response = Help(parameters=dic)
         return response
     else:
-        req = api.parse_call(request.parameters)
-        response = current_app.senpy.analyse(req)
+        params = api.parse_params(request.parameters, api.EVAL_PARAMS)
+        response = current_app.senpy.evaluate(params)
         return response
 
 
@@ -128,22 +256,24 @@ def api_root():
 @basic_api
 def plugins():
     sp = current_app.senpy
-    ptype = request.parameters.get('plugin_type')
-    plugins = sp.filter_plugins(plugin_type=ptype)
-    dic = Plugins(plugins=list(plugins.values()))
+    params = api.parse_params(request.parameters, api.PLUGINS_PARAMS)
+    ptype = params.get('plugin-type')
+    plugins = list(sp.analysis_plugins(plugin_type=ptype))
+    dic = Plugins(plugins=plugins)
     return dic
 
 
 @api_blueprint.route('/plugins/<plugin>/', methods=['POST', 'GET'])
 @basic_api
-def plugin(plugin=None):
+def plugin(plugin):
     sp = current_app.senpy
-    if plugin == 'default' and sp.default_plugin:
-        return sp.default_plugin
-    plugins = sp.filter_plugins(
-        id='plugins/{}'.format(plugin)) or sp.filter_plugins(name=plugin)
-    if plugins:
-        response = list(plugins.values())[0]
-    else:
-        return Error(message="Plugin not found", status=404)
-    return response
+    return sp.get_plugin(plugin)
+
+
+@api_blueprint.route('/datasets/', methods=['POST', 'GET'])
+@basic_api
+def datasets():
+    sp = current_app.senpy
+    datasets = sp.datasets
+    dic = Datasets(datasets=list(datasets.values()))
+    return dic

senpy/cli.py

@@ -1,3 +1,5 @@
+from __future__ import print_function
+
 import sys
 from .models import Error
 from .extensions import Senpy
@@ -27,12 +29,16 @@ def main_function(argv):
                               api.CLI_PARAMS,
                               api.API_PARAMS,
                               api.NIF_PARAMS)
-    plugin_folder = params['plugin_folder']
-    sp = Senpy(default_plugins=False, plugin_folder=plugin_folder)
+    plugin_folder = params['plugin-folder']
+    default_plugins = not params.get('no-default-plugins', False)
+    sp = Senpy(default_plugins=default_plugins, plugin_folder=plugin_folder)
     request = api.parse_call(params)
-    algos = request.parameters.get('algorithm', sp.plugins.keys())
-    for algo in algos:
-        sp.activate_plugin(algo)
+    algos = sp.get_plugins(request.parameters.get('algorithm', None))
+    if algos:
+        for algo in algos:
+            sp.activate_plugin(algo.name)
+    else:
+        sp.activate_all()
     res = sp.analyse(request)
     return res
 
@@ -42,9 +48,9 @@ def main():
     '''
     try:
         res = main_function(sys.argv[1:])
-        print(res.to_JSON())
+        print(res.serialize())
     except Error as err:
-        print(err.to_JSON())
+        print(err.serialize(), file=sys.stderr)
         sys.exit(2)
 
 

senpy/client.py

@@ -1,7 +1,6 @@
 import requests
 import logging
 from . import models
-from .plugins import default_plugin_type
 
 logger = logging.getLogger(__name__)
 
@@ -13,13 +12,24 @@ class Client(object):
     def analyse(self, input, method='GET', **kwargs):
         return self.request('/', method=method, input=input, **kwargs)
 
-    def plugins(self, ptype=default_plugin_type):
-        resp = self.request(path='/plugins', plugin_type=ptype).plugins
+    def evaluate(self, input, method='GET', **kwargs):
+        return self.request('/evaluate', method=method, input=input, **kwargs)
+
+    def plugins(self, *args, **kwargs):
+        resp = self.request(path='/plugins').plugins
         return {p.name: p for p in resp}
 
+    def datasets(self):
+        resp = self.request(path='/datasets').datasets
+        return {d.name: d for d in resp}
+
     def request(self, path=None, method='GET', **params):
-        url = '{}{}'.format(self.endpoint, path)
-        response = requests.request(method=method, url=url, params=params)
+        url = '{}{}'.format(self.endpoint.rstrip('/'), path)
+        if method == 'POST':
+            response = requests.post(url=url, data=params)
+        else:
+            response = requests.request(method=method, url=url, params=params)
+
         try:
             resp = models.from_dict(response.json())
         except Exception as ex:

senpy/extensions.py

@@ -6,18 +6,18 @@ from future import standard_library
 standard_library.install_aliases()
 
 from . import plugins, api
-from .plugins import SenpyPlugin
-from .models import Error
+from .models import Error, AggregatedEvaluation
+from .plugins import AnalysisPlugin
 from .blueprints import api_blueprint, demo_blueprint, ns_blueprint
 
 from threading import Thread
 from functools import partial
-
 import os
 import copy
 import errno
 import logging
-import traceback
+
+from . import gsitk_compat
 
 logger = logging.getLogger(__name__)
 
@@ -30,33 +30,32 @@ class Senpy(object):
                  plugin_folder=".",
                  data_folder=None,
                  default_plugins=False):
-        self.app = app
-        self._search_folders = set()
-        self._plugin_list = []
-        self._outdated = True
-        self._default = None
 
-        self.add_folder(plugin_folder)
-        if default_plugins:
-            self.add_folder('plugins', from_root=True)
-        else:
-            # Add only conversion plugins
-            self.add_folder(os.path.join('plugins', 'conversion'),
-                            from_root=True)
-
-        self.data_folder = data_folder or os.environ.get('SENPY_DATA',
-                                                         os.path.join(os.getcwd(),
-                                                                      'senpy_data'))
+        default_data = os.path.join(os.getcwd(), 'senpy_data')
+        self.data_folder = data_folder or os.environ.get('SENPY_DATA', default_data)
         try:
             os.makedirs(self.data_folder)
         except OSError as e:
             if e.errno == errno.EEXIST:
-                print('Directory not created.')
-            else:
+                logger.debug('Data folder exists: {}'.format(self.data_folder))
+            else:  # pragma: no cover
                 raise
 
+        self._default = None
+        self._plugins = {}
+        if plugin_folder:
+            self.add_folder(plugin_folder)
+
+        if default_plugins:
+            self.add_folder('plugins', from_root=True)
+        else:
+            # Add only conversion plugins
+            self.add_folder(os.path.join('plugins', 'postprocessing'),
+                            from_root=True)
+        self.app = app
         if app is not None:
             self.init_app(app)
+        self._conversion_candidates = {}
 
     def init_app(self, app):
         """ Initialise a flask app to add plugins to its context """
@@ -69,111 +68,120 @@ class Senpy(object):
         # otherwise fall back to the request context
         if hasattr(app, 'teardown_appcontext'):
             app.teardown_appcontext(self.teardown)
-        else:
+        else:  # pragma: no cover
             app.teardown_request(self.teardown)
         app.register_blueprint(api_blueprint, url_prefix="/api")
         app.register_blueprint(ns_blueprint, url_prefix="/ns")
         app.register_blueprint(demo_blueprint, url_prefix="/")
 
+    def add_plugin(self, plugin):
+        self._plugins[plugin.name.lower()] = plugin
+        self._conversion_candidates = {}
+
+    def delete_plugin(self, plugin):
+        del self._plugins[plugin.name.lower()]
+
+    def plugins(self, plugin_type=None, is_activated=True, **kwargs):
+        """ Return the plugins registered for a given application. Filtered by criteria  """
+        return sorted(plugins.pfilter(self._plugins,
+                                      plugin_type=plugin_type,
+                                      is_activated=is_activated,
+                                      **kwargs),
+                      key=lambda x: x.id)
+
+    def get_plugin(self, name, default=None):
+        if name == 'default':
+            return self.default_plugin
+        elif name == 'conversion':
+            return None
+
+        if name.lower() in self._plugins:
+            return self._plugins[name.lower()]
+
+        results = self.plugins(id='endpoint:plugins/{}'.format(name.lower()),
+                               plugin_type=None)
+        if results:
+            return results[0]
+
+        results = self.plugins(id=name,
+                               plugin_type=None)
+        if results:
+            return results[0]
+
+        msg = ("Plugin not found: '{}'\n"
+               "Make sure it is ACTIVATED\n"
+               "Valid algorithms: {}").format(name,
+                                              self._plugins.keys())
+        raise Error(message=msg, status=404)
+
+    def get_plugins(self, name):
+        try:
+            name = name.split(',')
+        except AttributeError:
+            pass  # Assume it is a tuple or a list
+        return tuple(self.get_plugin(n) for n in name)
+
+    def analysis_plugins(self, **kwargs):
+        """ Return only the analysis plugins that are active"""
+        candidates = self.plugins(**kwargs)
+        return list(plugins.pfilter(candidates, plugin_type=AnalysisPlugin))
+
     def add_folder(self, folder, from_root=False):
+        """ Find plugins in this folder and add them to this instance """
         if from_root:
             folder = os.path.join(os.path.dirname(__file__), folder)
         logger.debug("Adding folder: %s", folder)
         if os.path.isdir(folder):
-            self._search_folders.add(folder)
-            self._outdated = True
+            new_plugins = plugins.from_folder([folder],
+                                              data_folder=self.data_folder)
+            for plugin in new_plugins:
+                self.add_plugin(plugin)
         else:
-            logger.debug("Not a folder: %s", folder)
+            raise AttributeError("Not a folder or does not exist: %s", folder)
 
-    def _get_plugins(self, request):
-        if not self.analysis_plugins:
-            raise Error(
-                status=404,
-                message=("No plugins found."
-                         " Please install one."))
-        algos = request.parameters.get('algorithm', None)
-        if not algos:
-            if self.default_plugin:
-                algos = [self.default_plugin.name, ]
-            else:
-                raise Error(
-                    status=404,
-                    message="No default plugin found, and None provided")
-
-        plugins = list()
-        for algo in algos:
-            if algo not in self.plugins:
-                logger.debug(("The algorithm '{}' is not valid\n"
-                              "Valid algorithms: {}").format(algo,
-                                                             self.plugins.keys()))
-                raise Error(
-                    status=404,
-                    message="The algorithm '{}' is not valid".format(algo))
-            plugins.append(self.plugins[algo])
-        return plugins
-
-    def _process_entries(self, entries, req, plugins):
+    def _process(self, req, pending, done=None):
         """
         Recursively process the entries with the first plugin in the list, and pass the results
         to the rest of the plugins.
         """
-        if not plugins:
-            for i in entries:
-                yield i
-            return
-        plugin = plugins[0]
-        self._activate(plugin)  # Make sure the plugin is activated
-        specific_params = api.get_extra_params(req, plugin)
-        req.analysis.append({'plugin': plugin,
-                             'parameters': specific_params})
-        results = plugin.analyse_entries(entries, specific_params)
-        for i in self._process_entries(results, req, plugins[1:]):
-            yield i
+        done = done or []
+        if not pending:
+            return req
+
+        analysis = pending[0]
+        results = analysis.run(req)
+        results.activities.append(analysis)
+        done += analysis
+        return self._process(results, pending[1:], done)
 
     def install_deps(self):
-        for plugin in self.filter_plugins(is_activated=True):
-            plugins.install_deps(plugin)
+        logger.info('Installing dependencies')
+        # If a plugin is activated, its dependencies should already be installed
+        # Otherwise, it would've failed to activate.
+        plugins.install_deps(*self.plugins(is_activated=False))
 
-    def analyse(self, request):
+    def analyse(self, request, analyses=None):
         """
         Main method that analyses a request, either from CLI or HTTP.
         It takes a processed request, provided by the user, as returned
         by api.parse_call().
         """
+        if not self.plugins():
+            raise Error(
+                status=404,
+                message=("No plugins found."
+                         " Please install one."))
+        if analyses is None:
+            plugins = self.get_plugins(request.parameters['algorithm'])
+            analyses = api.parse_analyses(request.parameters, plugins)
         logger.debug("analysing request: {}".format(request))
-        try:
-            entries = request.entries
-            request.entries = []
-            plugins = self._get_plugins(request)
-            results = request
-            for i in self._process_entries(entries, results, plugins):
-                results.entries.append(i)
-            self.convert_emotions(results)
-            if 'with_parameters' not in results.parameters:
-                del results.parameters
-            logger.debug("Returning analysis result: {}".format(results))
-        except (Error, Exception) as ex:
-            if not isinstance(ex, Error):
-                msg = "Error during analysis: {} \n\t{}".format(ex,
-                                                                traceback.format_exc())
-                ex = Error(message=msg, status=500)
-            logger.exception('Error returning analysis result')
-            raise ex
-        results.analysis = [i['plugin'].id for i in results.analysis]
+        results = self._process(request, analyses)
+        logger.debug("Got analysis result: {}".format(results))
+        results = self.postprocess(results, analyses)
+        logger.debug("Returning post-processed result: {}".format(results))
         return results
 
-    def _conversion_candidates(self, fromModel, toModel):
-        candidates = self.filter_plugins(plugin_type='emotionConversionPlugin')
-        for name, candidate in candidates.items():
-            for pair in candidate.onyx__doesConversion:
-                logging.debug(pair)
-
-                if pair['onyx:conversionFrom'] == fromModel \
-                   and pair['onyx:conversionTo'] == toModel:
-                    # logging.debug('Found candidate: {}'.format(candidate))
-                    yield candidate
-
-    def convert_emotions(self, resp):
+    def convert_emotions(self, resp, analyses):
         """
         Conversion of all emotions in a response **in place**.
         In addition to converting from one model to another, it has
@@ -181,110 +189,202 @@ class Senpy(object):
         Needless to say, this is far from an elegant solution, but it works.
         @todo refactor and clean up
         """
-        plugins = [i['plugin'] for i in resp.analysis]
-        params = resp.parameters
-        toModel = params.get('emotionModel', None)
+
+        logger.debug("Converting emotions")
+        if 'parameters' not in resp:
+            logger.debug("NO PARAMETERS")
+            return resp
+
+        params = resp['parameters']
+        toModel = params.get('emotion-model', None)
         if not toModel:
-            return
+            logger.debug("NO tomodel PARAMETER")
+            return resp
 
         logger.debug('Asked for model: {}'.format(toModel))
         output = params.get('conversion', None)
-        candidates = {}
-        for plugin in plugins:
-            try:
-                fromModel = plugin.get('onyx:usesEmotionModel', None)
-                candidates[plugin.id] = next(self._conversion_candidates(fromModel, toModel))
-                logger.debug('Analysis plugin {} uses model: {}'.format(plugin.id, fromModel))
-            except StopIteration:
-                e = Error(('No conversion plugin found for: '
-                           '{} -> {}'.format(fromModel, toModel)))
-                e.original_response = resp
-                e.parameters = params
-                raise e
+
         newentries = []
+        done = []
         for i in resp.entries:
+
             if output == "full":
                 newemotions = copy.deepcopy(i.emotions)
             else:
                 newemotions = []
             for j in i.emotions:
-                plugname = j['prov:wasGeneratedBy']
-                candidate = candidates[plugname]
-                resp.analysis.append({'plugin': candidate,
-                                      'parameters': params})
+                activity = j['prov:wasGeneratedBy']
+                act = resp.activity(activity)
+                if not act:
+                    raise Error('Could not find the emotion model for {}'.format(activity))
+                fromModel = act.plugin['onyx:usesEmotionModel']
+                if toModel == fromModel:
+                    continue
+                candidate = self._conversion_candidate(fromModel, toModel)
+                if not candidate:
+                    e = Error(('No conversion plugin found for: '
+                              '{} -> {}'.format(fromModel, toModel)),
+                              status=404)
+                    e.original_response = resp
+                    e.parameters = params
+                    raise e
+
+                analysis = candidate.activity(params)
+                done.append(analysis)
                 for k in candidate.convert(j, fromModel, toModel, params):
-                    k.prov__wasGeneratedBy = candidate.id
+                    k.prov__wasGeneratedBy = analysis.id
                     if output == 'nested':
                         k.prov__wasDerivedFrom = j
                     newemotions.append(k)
             i.emotions = newemotions
             newentries.append(i)
         resp.entries = newentries
+        return resp
+
+    def _conversion_candidate(self, fromModel, toModel):
+        if not self._conversion_candidates:
+            candidates = {}
+            for conv in self.plugins(plugin_type=plugins.EmotionConversion):
+                for pair in conv.onyx__doesConversion:
+                    logging.debug(pair)
+                    key = (pair['onyx:conversionFrom'], pair['onyx:conversionTo'])
+                    if key not in candidates:
+                        candidates[key] = []
+                    candidates[key].append(conv)
+            self._conversion_candidates = candidates
+
+        key = (fromModel, toModel)
+        if key not in self._conversion_candidates:
+            return None
+        return self._conversion_candidates[key][0]
+
+    def postprocess(self, response, analyses):
+        '''
+        Transform the results from the analysis plugins.
+        It has some pre-defined post-processing like emotion conversion,
+        and it also allows plugins to auto-select themselves.
+        '''
+
+        response = self.convert_emotions(response, analyses)
+
+        for plug in self.plugins(plugin_type=plugins.PostProcessing):
+            if plug.check(response, response.activities):
+                activity = plug.activity(response.parameters)
+                response = plug.process(response, activity)
+        return response
+
+    def _get_datasets(self, request):
+        if not self.datasets:
+            raise Error(
+                status=404,
+                message=("No datasets found."
+                         " Please verify DatasetManager"))
+        datasets_name = request.parameters.get('dataset', None).split(',')
+        for dataset in datasets_name:
+            if dataset not in self.datasets:
+                logger.debug(("The dataset '{}' is not valid\n"
+                              "Valid datasets: {}").format(
+                                  dataset, self.datasets.keys()))
+                raise Error(
+                    status=404,
+                    message="The dataset '{}' is not valid".format(dataset))
+        dm = gsitk_compat.DatasetManager()
+        datasets = dm.prepare_datasets(datasets_name)
+        return datasets
+
+    @property
+    def datasets(self):
+        self._dataset_list = {}
+        dm = gsitk_compat.DatasetManager()
+        for item in dm.get_datasets():
+            for key in item:
+                if key in self._dataset_list:
+                    continue
+                properties = item[key]
+                properties['@id'] = key
+                self._dataset_list[key] = properties
+        return self._dataset_list
+
+    def evaluate(self, params):
+        logger.debug("evaluating request: {}".format(params))
+        results = AggregatedEvaluation()
+        results.parameters = params
+        datasets = self._get_datasets(results)
+        plugs = []
+        for plugname in params['algorithm']:
+            plugs = self.get_plugins(plugname)
+        for plug in plugs:
+            if not isinstance(plug, plugins.Evaluable):
+                raise Exception('Plugin {} can not be evaluated', plug.id)
+
+        for eval in plugins.evaluate(plugs, datasets):
+            results.evaluations.append(eval)
+        if 'with-parameters' not in results.parameters:
+            del results.parameters
+        logger.debug("Returning evaluation result: {}".format(results))
+        return results
 
     @property
     def default_plugin(self):
-        candidate = self._default
-        if not candidate:
-            candidates = self.filter_plugins(plugin_type='analysisPlugin',
-                                             is_activated=True)
+        if not self._default or not self._default.is_activated:
+            candidates = self.analysis_plugins()
             if len(candidates) > 0:
-                candidate = list(candidates.values())[0]
-        logger.debug("Default: {}".format(candidate))
-        return candidate
+                self._default = candidates[0]
+            else:
+                self._default = None
+            logger.debug("Default: {}".format(self._default))
+        return self._default
 
     @default_plugin.setter
     def default_plugin(self, value):
-        if isinstance(value, SenpyPlugin):
+        if isinstance(value, plugins.Plugin):
+            if not value.is_activated:
+                raise AttributeError('The default plugin has to be activated.')
             self._default = value
-        else:
-            self._default = self.plugins[value]
 
-    def activate_all(self, sync=True):
+        else:
+            self._default = self._plugins[value.lower()]
+
+    def activate_all(self, sync=True, allow_fail=False):
         ps = []
-        for plug in self.plugins.keys():
-            ps.append(self.activate_plugin(plug, sync=sync))
+        for plug in self._plugins.keys():
+            try:
+                self.activate_plugin(plug, sync=sync)
+            except Exception as ex:
+                if not allow_fail:
+                    raise
+                logger.error('Could not activate {}: {}'.format(plug, ex))
         return ps
 
     def deactivate_all(self, sync=True):
         ps = []
-        for plug in self.plugins.keys():
+        for plug in self._plugins.keys():
             ps.append(self.deactivate_plugin(plug, sync=sync))
         return ps
 
-    def _set_active(self, plugin, active=True, *args, **kwargs):
-        ''' We're using a variable in the plugin itself to activate/deactive plugins.\
-        Note that plugins may activate themselves by setting this variable.
-        '''
-        plugin.is_activated = active
-
     def _activate(self, plugin):
         success = False
         with plugin._lock:
             if plugin.is_activated:
                 return
-            try:
-                plugin.activate()
-                msg = "Plugin activated: {}".format(plugin.name)
-                logger.info(msg)
-                success = True
-                self._set_active(plugin, success)
-            except Exception as ex:
-                msg = "Error activating plugin {} - {} : \n\t{}".format(
-                    plugin.name, ex, traceback.format_exc())
-                logger.error(msg)
-                raise Error(msg)
+            plugin._activate()
+            msg = "Plugin activated: {}".format(plugin.name)
+            logger.info(msg)
+            success = plugin.is_activated
+        return success
 
     def activate_plugin(self, plugin_name, sync=True):
-        try:
-            plugin = self.plugins[plugin_name]
-        except KeyError:
+        plugin_name = plugin_name.lower()
+        if plugin_name not in self._plugins:
             raise Error(
                 message="Plugin not found: {}".format(plugin_name), status=404)
+        plugin = self._plugins[plugin_name]
 
         logger.info("Activating plugin: {}".format(plugin.name))
 
-        if sync or 'async' in plugin and not plugin.async:
-            self._activate(plugin)
+        if sync or not getattr(plugin, 'async', True) or getattr(
+                plugin, 'sync', False):
+            return self._activate(plugin)
         else:
             th = Thread(target=partial(self._activate, plugin))
             th.start()
@@ -294,46 +394,23 @@ class Senpy(object):
         with plugin._lock:
             if not plugin.is_activated:
                 return
-            try:
-                plugin.deactivate()
-                logger.info("Plugin deactivated: {}".format(plugin.name))
-            except Exception as ex:
-                logger.error(
-                    "Error deactivating plugin {}: {}".format(plugin.name, ex))
-                logger.error("Trace: {}".format(traceback.format_exc()))
+            plugin._deactivate()
+            logger.info("Plugin deactivated: {}".format(plugin.name))
 
     def deactivate_plugin(self, plugin_name, sync=True):
-        try:
-            plugin = self.plugins[plugin_name]
-        except KeyError:
+        plugin_name = plugin_name.lower()
+        if plugin_name not in self._plugins:
             raise Error(
                 message="Plugin not found: {}".format(plugin_name), status=404)
+        plugin = self._plugins[plugin_name]
 
-        self._set_active(plugin, False)
-
-        if sync or 'async' in plugin and not plugin.async:
-            self._deactivate(plugin)
+        if sync or not getattr(plugin, 'async', True) or not getattr(
+                plugin, 'sync', False):
+            plugin._deactivate()
         else:
-            th = Thread(target=partial(self._deactivate, plugin))
+            th = Thread(target=plugin.deactivate)
             th.start()
             return th
 
     def teardown(self, exception):
         pass
-
-    @property
-    def plugins(self):
-        """ Return the plugins registered for a given application.  """
-        if self._outdated:
-            self._plugin_list = plugins.load_plugins(self._search_folders,
-                                                     data_folder=self.data_folder)
-            self._outdated = False
-        return self._plugin_list
-
-    def filter_plugins(self, **kwargs):
-        return plugins.pfilter(self.plugins, **kwargs)
-
-    @property
-    def analysis_plugins(self):
-        """ Return only the analysis plugins """
-        return self.filter_plugins(plugin_type='analysisPlugin')

senpy/gsitk_compat.py

@@ -0,0 +1,31 @@
+import logging
+
+from pkg_resources import parse_version, get_distribution, DistributionNotFound
+
+logger = logging.getLogger(__name__)
+
+MSG = 'GSITK is not (properly) installed.'
+IMPORTMSG = '{} Some functions will be unavailable.'.format(MSG)
+RUNMSG = '{} Install it to use this function.'.format(MSG)
+
+
+def raise_exception(*args, **kwargs):
+    raise Exception(RUNMSG)
+
+
+try:
+    gsitk_distro = get_distribution("gsitk")
+    GSITK_VERSION = parse_version(gsitk_distro.version)
+
+    from gsitk.datasets.datasets import DatasetManager
+    from gsitk.evaluation.evaluation import Evaluation as Eval  # noqa: F401
+    from gsitk.evaluation.evaluation import EvalPipeline  # noqa: F401
+    from sklearn.pipeline import Pipeline
+    modules = locals()
+    GSITK_AVAILABLE = True
+except (DistributionNotFound, ImportError) as err:
+    logger.debug('Error importing GSITK: {}'.format(err))
+    logger.warning(IMPORTMSG)
+    GSITK_AVAILABLE = False
+    GSITK_VERSION = ()
+    DatasetManager = Eval = Pipeline = raise_exception

senpy/meta.py

@@ -0,0 +1,287 @@
+'''
+Meta-programming for the models.
+'''
+import os
+import json
+import jsonschema
+import inspect
+import copy
+
+from abc import ABCMeta
+from collections import MutableMapping, namedtuple
+
+
+class BaseMeta(ABCMeta):
+    '''
+    Metaclass for models. It extracts the default values for the fields in
+    the model.
+
+    For instance, instances of the following class wouldn't need to mark
+    their version or description on initialization:
+
+    .. code-block:: python
+
+       class MyPlugin(Plugin):
+           version=0.3
+           description='A dull plugin'
+
+
+    Note that these operations could be included in the __init__ of the
+    class, but it would be very inefficient.
+    '''
+    _subtypes = {}
+
+    def __new__(mcs, name, bases, attrs, **kwargs):
+        register_afterwards = False
+        defaults = {}
+        aliases = {}
+
+        attrs = mcs.expand_with_schema(name, attrs)
+        if 'schema' in attrs:
+            register_afterwards = True
+        for base in bases:
+            if hasattr(base, '_defaults'):
+                defaults.update(getattr(base, '_defaults'))
+            if hasattr(base, '_aliases'):
+                aliases.update(getattr(base, '_aliases'))
+
+        info, rest = mcs.split_attrs(attrs)
+
+        for i in list(info.keys()):
+            if isinstance(info[i], _Alias):
+                aliases[i] = info[i].indict
+                if info[i].default is not None:
+                    defaults[i] = info[i].default
+            else:
+                defaults[i] = info[i]
+
+        rest['_defaults'] = defaults
+        rest['_aliases'] = aliases
+
+        cls = super(BaseMeta, mcs).__new__(mcs, name, tuple(bases), rest)
+
+        if register_afterwards:
+            mcs.register(cls, defaults['@type'])
+        return cls
+
+    @classmethod
+    def register(mcs, rsubclass, rtype=None):
+        mcs._subtypes[rtype or rsubclass.__name__] = rsubclass
+
+    @staticmethod
+    def expand_with_schema(name, attrs):
+        if 'schema' in attrs:  # Schema specified by name
+            schema_file = '{}.json'.format(attrs['schema'])
+        elif 'schema_file' in attrs:
+            schema_file = attrs['schema_file']
+            del attrs['schema_file']
+        else:
+            return attrs
+
+        if '/' not in 'schema_file':
+            thisdir = os.path.dirname(os.path.realpath(__file__))
+            schema_file = os.path.join(thisdir,
+                                       'schemas',
+                                       schema_file)
+
+        schema_path = 'file://' + schema_file
+
+        with open(schema_file) as f:
+            schema = json.load(f)
+
+        resolver = jsonschema.RefResolver(schema_path, schema)
+        if '@type' not in attrs:
+            attrs['@type'] = name
+        attrs['_schema_file'] = schema_file
+        attrs['schema'] = schema
+        attrs['_validator'] = jsonschema.Draft4Validator(schema, resolver=resolver)
+
+        schema_defaults = BaseMeta.get_defaults(attrs['schema'])
+        attrs.update(schema_defaults)
+
+        return attrs
+
+    @staticmethod
+    def is_func(v):
+        return inspect.isroutine(v) or inspect.ismethod(v) or \
+            inspect.ismodule(v) or isinstance(v, property)
+
+    @staticmethod
+    def is_internal(k):
+        return k[0] == '_' or k == 'schema' or k == 'data'
+
+    @staticmethod
+    def get_key(key):
+        if key[0] != '_':
+            key = key.replace("__", ":", 1)
+        return key
+
+    @staticmethod
+    def split_attrs(attrs):
+        '''
+        Extract the attributes of the class.
+
+        This allows adding default values in the class definition.
+        e.g.:
+        '''
+        isattr = {}
+        rest = {}
+        for key, value in attrs.items():
+            if not (BaseMeta.is_internal(key)) and (not BaseMeta.is_func(value)):
+                isattr[key] = value
+            else:
+                rest[key] = value
+        return isattr, rest
+
+    @staticmethod
+    def get_defaults(schema):
+        temp = {}
+        for obj in [
+                schema,
+        ] + schema.get('allOf', []):
+            for k, v in obj.get('properties', {}).items():
+                if 'default' in v and k not in temp:
+                    temp[k] = v['default']
+        return temp
+
+
+def make_property(key, default=None):
+
+    def fget(self):
+        if default:
+            return self.get(key, copy.copy(default))
+        return self[key]
+
+    def fdel(self):
+        del self[key]
+
+    def fset(self, value):
+        self[key] = value
+
+    return fget, fset, fdel
+
+
+class CustomDict(MutableMapping, object):
+    '''
+    A dictionary whose elements can also be accessed as attributes. Since some
+    characters are not valid in the dot-notation, the attribute names also
+    converted. e.g.:
+
+    > d = CustomDict()
+    > d.key = d['ns:name'] = 1
+    > d.key == d['key']
+    True
+    > d.ns__name == d['ns:name']
+    '''
+
+    _defaults = {}
+    _aliases = {'id': '@id'}
+
+    def __init__(self, *args, **kwargs):
+        super(CustomDict, self).__init__()
+        for k, v in self._defaults.items():
+            self[k] = copy.copy(v)
+        for arg in args:
+            self.update(arg)
+        for k, v in kwargs.items():
+            self[k] = v
+        return self
+
+    def serializable(self, **kwargs):
+        def ser_or_down(item):
+            if hasattr(item, 'serializable'):
+                return item.serializable(**kwargs)
+            elif isinstance(item, dict):
+                temp = dict()
+                for kp in item:
+                    vp = item[kp]
+                    temp[kp] = ser_or_down(vp)
+                return temp
+            elif isinstance(item, list) or isinstance(item, set):
+                return list(ser_or_down(i) for i in item)
+            else:
+                return item
+
+        return ser_or_down(self.as_dict(**kwargs))
+
+    def __getitem__(self, key):
+        return self.__dict__[key]
+
+    def __setitem__(self, key, value):
+        '''Do not insert data directly, there might be a property in that key. '''
+        key = self._key_to_attr(key)
+        return setattr(self, key, value)
+
+    def __delitem__(self, key):
+        key = self._key_to_attr(key)
+        del self.__dict__[key]
+
+    def as_dict(self, verbose=True, aliases=False):
+        attrs = self.__dict__.keys()
+        if not verbose and hasattr(self, '_terse_keys'):
+            attrs = self._terse_keys + ['@type', '@id']
+        res = {k: getattr(self, k) for k in attrs
+               if not self._internal_key(k) and hasattr(self, k)}
+        if not aliases:
+            return res
+        for k, ok in self._aliases.items():
+            if ok in res:
+                res[k] = getattr(res, ok)
+                del res[ok]
+        return res
+
+    def __iter__(self):
+        return (k for k in self.__dict__ if not self._internal_key(k))
+
+    def __len__(self):
+        return len(self.__dict__)
+
+    def update(self, other):
+        for k, v in other.items():
+            self[k] = v
+
+    def _attr_to_key(self, key):
+        key = key.replace("__", ":", 1)
+        key = self._aliases.get(key, key)
+        return key
+
+    def _key_to_attr(self, key):
+        if self._internal_key(key):
+            return key
+
+        if key in self._aliases:
+            key = self._aliases[key]
+        else:
+            key = key.replace(":", "__", 1)
+        return key
+
+    def __getattr__(self, key):
+        nkey = self._attr_to_key(key)
+        if nkey in self.__dict__:
+            return self.__dict__[nkey]
+        elif nkey == key:
+            raise AttributeError("Key not found: {}".format(key))
+        return getattr(self, nkey)
+
+    def __setattr__(self, key, value):
+        super(CustomDict, self).__setattr__(self._attr_to_key(key), value)
+
+    def __delattr__(self, key):
+        super(CustomDict, self).__delattr__(self._attr_to_key(key))
+
+    @staticmethod
+    def _internal_key(key):
+        return key[0] == '_'
+
+    def __str__(self):
+        return json.dumps(self.serializable(), sort_keys=True, indent=4)
+
+    def __repr__(self):
+        return json.dumps(self.serializable(), sort_keys=True, indent=4)
+
+
+_Alias = namedtuple('Alias', ['indict', 'default'])
+
+
+def alias(key, default=None):
+    return _Alias(key, default)

senpy/models.py

@@ -6,27 +6,37 @@ For compatibility with Py3 and for easier debugging, this new version drops
 introspection and adds all arguments to the models.
 '''
 from __future__ import print_function
-from six import string_types
+from future import standard_library
+standard_library.install_aliases()
+
+from future.utils import with_metaclass
+from past.builtins import basestring
+
+from jinja2 import Environment, BaseLoader
 
 import time
 import copy
 import json
 import os
 import jsonref
-import jsonschema
-
 from flask import Response as FlaskResponse
 from pyld import jsonld
 
-from rdflib import Graph
-
 import logging
+import jmespath
 
+logging.getLogger('rdflib').setLevel(logging.WARN)
 logger = logging.getLogger(__name__)
 
+from rdflib import Graph
+
+
+from .meta import BaseMeta, CustomDict, alias
+
 DEFINITIONS_FILE = 'definitions.json'
-CONTEXT_PATH = os.path.join(
-    os.path.dirname(os.path.realpath(__file__)), 'schemas', 'context.jsonld')
+CONTEXT_PATH = os.path.join(os.path.dirname(os.path.realpath(__file__)),
+                            'schemas',
+                            'context.jsonld')
 
 
 def get_schema_path(schema_file, absolute=False):
@@ -45,40 +55,99 @@ def read_schema(schema_file, absolute=False):
         return jsonref.load(f, base_uri=schema_uri)
 
 
-base_schema = read_schema(DEFINITIONS_FILE)
+def dump_schema(schema):
+    return jsonref.dumps(schema)
 
 
-class Context(dict):
-    @staticmethod
-    def load(context):
-        logging.debug('Loading context: {}'.format(context))
-        if not context:
+def load_context(context):
+    logging.debug('Loading context: {}'.format(context))
+    if not context:
+        return context
+    elif isinstance(context, list):
+        contexts = []
+        for c in context:
+            contexts.append(load_context(c))
+        return contexts
+    elif isinstance(context, dict):
+        return dict(context)
+    elif isinstance(context, basestring):
+        try:
+            with open(context) as f:
+                return dict(json.loads(f.read()))
+        except IOError:
             return context
-        elif isinstance(context, list):
-            contexts = []
-            for c in context:
-                contexts.append(Context.load(c))
-            return contexts
-        elif isinstance(context, dict):
-            return Context(context)
-        elif isinstance(context, string_types):
-            try:
-                with open(context) as f:
-                    return Context(json.loads(f.read()))
-            except IOError:
-                return context
-        else:
-            raise AttributeError('Please, provide a valid context')
+    else:
+        raise AttributeError('Please, provide a valid context')
 
 
-base_context = Context.load(CONTEXT_PATH)
+base_context = load_context(CONTEXT_PATH)
 
 
-class SenpyMixin(object):
+def register(rsubclass, rtype=None):
+    BaseMeta.register(rsubclass, rtype)
+
+
+class BaseModel(with_metaclass(BaseMeta, CustomDict)):
+    '''
+    Entities of the base model are a special kind of dictionary that emulates
+    a JSON-LD object. The structure of the dictionary is checked via JSON-schema.
+    For convenience, the values can also be accessed as attributes
+    (a la Javascript). e.g.:
+
+    >>> myobject.key == myobject['key']
+    True
+    >>> myobject.ns__name == myobject['ns:name']
+    True
+
+    Additionally, subclasses of this class can specify default values for their
+    instances. These defaults are inherited by subclasses. e.g.:
+
+    >>> class NewModel(BaseModel):
+    ...     mydefault = 5
+    >>> n1 = NewModel()
+    >>> n1['mydefault'] == 5
+    True
+    >>> n1.mydefault = 3
+    >>> n1['mydefault'] = 3
+    True
+    >>> n2 = NewModel()
+    >>> n2 == 5
+    True
+    >>> class SubModel(NewModel):
+            pass
+    >>> subn = SubModel()
+    >>> subn.mydefault == 5
+    True
+
+    Lastly, every subclass that also specifies a schema will get registered, so it
+    is possible to deserialize JSON and get the right type.
+    i.e. to recover an instance of the original class from a plain JSON.
+
+    '''
+
+    # schema_file = DEFINITIONS_FILE
     _context = base_context["@context"]
 
+    def __init__(self, *args, **kwargs):
+        auto_id = kwargs.pop('_auto_id', False)
+
+        super(BaseModel, self).__init__(*args, **kwargs)
+
+        if auto_id:
+            self.id
+
+    @property
+    def id(self):
+        if '@id' not in self:
+            self['@id'] = 'prefix:{}_{}'.format(type(self).__name__, time.time())
+        return self['@id']
+
+    @id.setter
+    def id(self, value):
+        self['@id'] = value
+
     def flask(self,
-              in_headers=True,
+              in_headers=False,
               headers=None,
               outformat='json-ld',
               **kwargs):
@@ -102,26 +171,37 @@ class SenpyMixin(object):
             })
         return FlaskResponse(
             response=content,
-            status=getattr(self, "status", 200),
+            status=self.get('status', 200),
             headers=headers,
             mimetype=mimetype)
 
-    def serialize(self, format='json-ld', with_mime=False, **kwargs):
-        js = self.jsonld(**kwargs)
-        if format == 'json-ld':
+    def serialize(self, format='json-ld', with_mime=False,
+                  template=None, prefix=None, fields=None, **kwargs):
+        js = self.jsonld(prefix=prefix, **kwargs)
+        if template is not None:
+            rtemplate = Environment(loader=BaseLoader).from_string(template)
+            content = rtemplate.render(**self)
+            mimetype = 'text'
+        elif fields is not None:
+            # Emulate field selection by constructing a template
+            content = json.dumps(jmespath.search(fields, js))
+            mimetype = 'text'
+        elif format == 'json-ld':
             content = json.dumps(js, indent=2, sort_keys=True)
             mimetype = "application/json"
-        elif format in ['turtle', ]:
-            logger.debug(js)
+        elif format in ['turtle', 'ntriples']:
             content = json.dumps(js, indent=2, sort_keys=True)
+            logger.debug(js)
+            context = [self._context, {'prefix': prefix, '@base': prefix}]
             g = Graph().parse(
                 data=content,
                 format='json-ld',
-                base=kwargs.get('prefix'),
-                context=self._context)
+                prefix=prefix,
+                context=context)
             logger.debug(
                 'Parsing with prefix: {}'.format(kwargs.get('prefix')))
-            content = g.serialize(format='turtle').decode('utf-8')
+            content = g.serialize(format=format,
+                                  prefix=prefix).decode('utf-8')
             mimetype = 'text/{}'.format(format)
         else:
             raise Error('Unknown outformat: {}'.format(format))
@@ -130,51 +210,40 @@ class SenpyMixin(object):
         else:
             return content
 
-    def serializable(self):
-        def ser_or_down(item):
-            if hasattr(item, 'serializable'):
-                return item.serializable()
-            elif isinstance(item, dict):
-                temp = dict()
-                for kp in item:
-                    vp = item[kp]
-                    temp[kp] = ser_or_down(vp)
-                return temp
-            elif isinstance(item, list) or isinstance(item, set):
-                return list(ser_or_down(i) for i in item)
-            else:
-                return item
-
-        return ser_or_down(self._plain_dict())
-
     def jsonld(self,
-               with_context=True,
+               with_context=False,
                context_uri=None,
                prefix=None,
-               expanded=False):
-        ser = self.serializable()
+               base=None,
+               expanded=False,
+               **kwargs):
+
+        result = self.serializable(**kwargs)
 
-        result = jsonld.compact(
-            ser,
-            self._context,
-            options={
-                'base': prefix,
-                'expandContext': self._context,
-                'senpy': prefix
-            })
-        if context_uri:
-            result['@context'] = context_uri
         if expanded:
             result = jsonld.expand(
-                result, options={'base': prefix,
-                                 'expandContext': self._context})
+                result,
+                options={
+                    'expandContext': [
+                        self._context,
+                        {
+                            'prefix': prefix,
+                            'endpoint': prefix
+                        }
+                    ]
+                }
+            )[0]
         if not with_context:
-            del result['@context']
-        return result
+            try:
+                del result['@context']
+            except KeyError:
+                pass
+        elif context_uri:
+            result['@context'] = context_uri
+        else:
+            result['@context'] = self._context
 
-    def to_JSON(self, *args, **kwargs):
-        js = json.dumps(self.jsonld(*args, **kwargs), indent=4, sort_keys=True)
-        return js
+        return result
 
     def validate(self, obj=None):
         if not obj:
@@ -183,86 +252,26 @@ class SenpyMixin(object):
             obj = obj.jsonld()
         self._validator.validate(obj)
 
-    def __str__(self):
-        return str(self.serialize())
+    def prov(self, another):
+        self['prov:wasGeneratedBy'] = another.id
 
 
-class BaseModel(SenpyMixin, dict):
-
-    schema = base_schema
-
-    def __init__(self, *args, **kwargs):
-        if 'id' in kwargs:
-            self.id = kwargs.pop('id')
-        elif kwargs.pop('_auto_id', True):
-            self.id = '_:{}_{}'.format(type(self).__name__, time.time())
-        temp = dict(*args, **kwargs)
-
-        for obj in [
-                self.schema,
-        ] + self.schema.get('allOf', []):
-            for k, v in obj.get('properties', {}).items():
-                if 'default' in v and k not in temp:
-                    temp[k] = copy.deepcopy(v['default'])
-
-        for i in temp:
-            nk = self._get_key(i)
-            if nk != i:
-                temp[nk] = temp[i]
-                del temp[i]
-        try:
-            temp['@type'] = getattr(self, '@type')
-        except AttributeError:
-            logger.warn('Creating an instance of an unknown model')
-
-        super(BaseModel, self).__init__(temp)
-
-    def _get_key(self, key):
-        if key is 'id':
-            key = '@id'
-        key = key.replace("__", ":", 1)
-        return key
-
-    def __delitem__(self, key):
-        dict.__delitem__(self, key)
-
-    def __getattr__(self, key):
-        try:
-            return self.__getitem__(self._get_key(key))
-        except KeyError:
-            raise AttributeError(key)
-
-    def __setattr__(self, key, value):
-        self.__setitem__(self._get_key(key), value)
-
-    def __delattr__(self, key):
-        try:
-            object.__delattr__(self, key)
-        except AttributeError:
-            self.__delitem__(self._get_key(key))
-
-    def _plain_dict(self):
-        d = {k: v for (k, v) in self.items() if k[0] != "_"}
-        return d
+def subtypes():
+    return BaseMeta._subtypes
 
 
-def register(rsubclass, rtype=None):
-    _subtypes[rtype or rsubclass.__name__] = rsubclass
-
-
-_subtypes = {}
-
-
-def from_dict(indict, cls=None):
+def from_dict(indict, cls=None, warn=True):
     if not cls:
         target = indict.get('@type', None)
+        cls = BaseModel
         try:
-            if target and target in _subtypes:
-                cls = _subtypes[target]
-            else:
-                cls = BaseModel
-        except Exception:
-            cls = BaseModel
+            cls = subtypes()[target]
+        except KeyError:
+            pass
+
+    if cls == BaseModel and warn:
+        logger.warning('Created an instance of an unknown model')
+
     outdict = dict()
     for k, v in indict.items():
         if k == '@context':
@@ -270,10 +279,11 @@ def from_dict(indict, cls=None):
         elif isinstance(v, dict):
             v = from_dict(indict[k])
         elif isinstance(v, list):
+            v = v[:]
             for ix, v2 in enumerate(v):
                 if isinstance(v2, dict):
                     v[ix] = from_dict(v2)
-        outdict[k] = v
+        outdict[k] = copy.copy(v)
     return cls(**outdict)
 
 
@@ -281,104 +291,226 @@ def from_string(string, **kwargs):
     return from_dict(json.loads(string), **kwargs)
 
 
-def from_json(injson):
+def from_json(injson, **kwargs):
     indict = json.loads(injson)
-    return from_dict(indict)
+    return from_dict(indict, **kwargs)
 
 
-def from_schema(name, schema=None, schema_file=None, base_classes=None):
-    base_classes = base_classes or []
-    base_classes.append(BaseModel)
-    schema_file = schema_file or '{}.json'.format(name)
-    class_name = '{}{}'.format(name[0].upper(), name[1:])
-    if '/' not in 'schema_file':
-        schema_file = os.path.join(os.path.dirname(os.path.realpath(__file__)),
-                                   'schemas',
-                                   schema_file)
+class Entry(BaseModel):
+    schema = 'entry'
 
-    schema_path = 'file://' + schema_file
-
-    with open(schema_file) as f:
-        schema = json.load(f)
-
-    dct = {}
-
-    resolver = jsonschema.RefResolver(schema_path, schema)
-    dct['@type'] = name
-    dct['_schema_file'] = schema_file
-    dct['schema'] = schema
-    dct['_validator'] = jsonschema.Draft4Validator(schema, resolver=resolver)
-
-    newclass = type(class_name, tuple(base_classes), dct)
-
-    register(newclass, name)
-    return newclass
+    text = alias('nif:isString')
+    sentiments = alias('marl:hasOpinion', [])
+    emotions = alias('onyx:hasEmotionSet', [])
 
 
-def _add_from_schema(*args, **kwargs):
-    generatedClass = from_schema(*args, **kwargs)
-    globals()[generatedClass.__name__] = generatedClass
-    del generatedClass
+class Sentiment(BaseModel):
+    schema = 'sentiment'
+
+    polarity = alias('marl:hasPolarity')
+    polarityValue = alias('marl:polarityValue')
 
 
-for i in [
-        'analysis',
-        'emotion',
-        'emotionConversion',
-        'emotionConversionPlugin',
-        'emotionAnalysis',
-        'emotionModel',
-        'emotionPlugin',
-        'emotionSet',
-        'entry',
-        'help',
-        'plugin',
-        'plugins',
-        'response',
-        'results',
-        'sentiment',
-        'sentimentPlugin',
-        'suggestion',
-]:
-    _add_from_schema(i)
+class Error(BaseModel, Exception):
+    schema = 'error'
 
-_ErrorModel = from_schema('error')
-
-
-class Error(SenpyMixin, Exception):
-    def __init__(self, message, *args, **kwargs):
-        super(Error, self).__init__(self, message, message)
-        self._error = _ErrorModel(message=message, *args, **kwargs)
+    def __init__(self, message='Generic senpy exception', *args, **kwargs):
+        Exception.__init__(self, message)
+        super(Error, self).__init__(*args, **kwargs)
         self.message = message
 
-    def validate(self, obj=None):
-        self._error.validate()
-
-    def __getitem__(self, key):
-        return self._error[key]
-
-    def __setitem__(self, key, value):
-        self._error[key] = value
-
-    def __delitem__(self, key):
-        del self._error[key]
-
-    def __getattr__(self, key):
-        if key != '_error' and hasattr(self._error, key):
-            return getattr(self._error, key)
-        raise AttributeError(key)
-
-    def __setattr__(self, key, value):
-        if key != '_error':
-            return setattr(self._error, key, value)
-        else:
-            super(Error, self).__setattr__(key, value)
-
-    def __delattr__(self, key):
-        delattr(self._error, key)
-
     def __str__(self):
-        return str(self.to_JSON(with_context=False))
+        if not hasattr(self, 'errors'):
+            return self.message
+        return '{}:\n\t{}'.format(self.message, self.errors)
+
+    def __hash__(self):
+        return Exception.__hash__(self)
 
 
-register(Error, 'error')
+class AggregatedEvaluation(BaseModel):
+    schema = 'aggregatedEvaluation'
+
+    evaluations = alias('senpy:evaluations', [])
+
+
+class Dataset(BaseModel):
+    schema = 'dataset'
+
+
+class Datasets(BaseModel):
+    schema = 'datasets'
+
+    datasets = []
+
+
+class Emotion(BaseModel):
+    schema = 'emotion'
+
+
+class EmotionConversion(BaseModel):
+    schema = 'emotionConversion'
+
+
+class EmotionConversionPlugin(BaseModel):
+    schema = 'emotionConversionPlugin'
+
+
+class EmotionAnalysis(BaseModel):
+    schema = 'emotionAnalysis'
+
+
+class EmotionModel(BaseModel):
+    schema = 'emotionModel'
+    onyx__hasEmotionCategory = []
+
+
+class EmotionPlugin(BaseModel):
+    schema = 'emotionPlugin'
+
+
+class EmotionSet(BaseModel):
+    schema = 'emotionSet'
+
+    onyx__hasEmotion = []
+
+
+class Evaluation(BaseModel):
+    schema = 'evaluation'
+
+    metrics = alias('senpy:metrics', [])
+
+
+class Entity(BaseModel):
+    schema = 'entity'
+
+
+class Help(BaseModel):
+    schema = 'help'
+
+
+class Metric(BaseModel):
+    schema = 'metric'
+
+
+class Parameter(BaseModel):
+    schema = 'parameter'
+
+
+class Plugins(BaseModel):
+    schema = 'plugins'
+
+    plugins = []
+
+
+class Response(BaseModel):
+    schema = 'response'
+
+
+class Results(BaseModel):
+    schema = 'results'
+
+    _terse_keys = ['entries', ]
+
+    activities = []
+    entries = []
+
+    def activity(self, id):
+        for i in self.activities:
+            if i.id == id:
+                return i
+        return None
+
+
+class SentimentPlugin(BaseModel):
+    schema = 'sentimentPlugin'
+
+
+class Suggestion(BaseModel):
+    schema = 'suggestion'
+
+
+class Topic(BaseModel):
+    schema = 'topic'
+
+
+class Analysis(BaseModel):
+    '''
+    A prov:Activity that results of executing a Plugin on an entry with a set of
+    parameters.
+    '''
+    schema = 'analysis'
+
+    parameters = alias('prov:used', [])
+    algorithm = alias('prov:wasAssociatedWith', [])
+
+    @property
+    def params(self):
+        outdict = {}
+        outdict['algorithm'] = self.algorithm
+        for param in self.parameters:
+            outdict[param['name']] = param['value']
+        return outdict
+
+    @params.setter
+    def params(self, value):
+        for k, v in value.items():
+            for param in self.parameters:
+                if param.name == k:
+                    param.value = v
+                    break
+            else:
+                self.parameters.append(Parameter(name=k, value=v))  # noqa: F821
+
+    def param(self, key, default=None):
+        for param in self.parameters:
+            if param['name'] == key:
+                return param['value']
+        return default
+
+    @property
+    def plugin(self):
+        return self._plugin
+
+    @plugin.setter
+    def plugin(self, value):
+        self._plugin = value
+        self['prov:wasAssociatedWith'] = value.id
+
+    def run(self, request):
+        return self.plugin.process(request, self)
+
+
+class Plugin(BaseModel):
+    schema = 'plugin'
+    extra_params = {}
+
+    def activity(self, parameters=None):
+        '''Generate an Analysis (prov:Activity) from this plugin and the given parameters'''
+        a = Analysis()
+        a.plugin = self
+        if parameters:
+            a.params = parameters
+        return a
+
+
+# More classes could be added programmatically
+
+def _class_from_schema(name, schema=None, schema_file=None, base_classes=None):
+    base_classes = base_classes or []
+    base_classes.append(BaseModel)
+    attrs = {}
+    if schema:
+        attrs['schema'] = schema
+    elif schema_file:
+        attrs['schema_file'] = schema_file
+    else:
+        attrs['schema'] = name
+    name = "".join((name[0].upper(), name[1:]))
+    return BaseMeta(name, base_classes, attrs)
+
+
+def _add_class_from_schema(*args, **kwargs):
+    generatedClass = _class_from_schema(*args, **kwargs)
+    globals()[generatedClass.__name__] = generatedClass
+    del generatedClass

senpy/plugins/example/emoRand/emoRand.senpy

@@ -1,9 +0,0 @@
----
-name: emoRand
-module: emoRand
-description: A sample plugin that returns a random emotion annotation
-author: "@balkian"
-version: '0.1'
-url: "https://github.com/gsi-upm/senpy-plugins-community"
-requirements: {}
-onyx:usesEmotionModel: "emoml:big6"

senpy/plugins/example/rand/rand.py

@@ -1,34 +0,0 @@
-import random
-
-from senpy.plugins import SentimentPlugin
-from senpy.models import Sentiment, Entry
-
-
-class RandPlugin(SentimentPlugin):
-    def analyse_entry(self, entry, params):
-        lang = params.get("language", "auto")
-
-        polarity_value = max(-1, min(1, random.gauss(0.2, 0.2)))
-        polarity = "marl:Neutral"
-        if polarity_value > 0:
-            polarity = "marl:Positive"
-        elif polarity_value < 0:
-            polarity = "marl:Negative"
-        sentiment = Sentiment({
-            "marl:hasPolarity": polarity,
-            "marl:polarityValue": polarity_value
-        })
-        sentiment["prov:wasGeneratedBy"] = self.id
-        entry.sentiments.append(sentiment)
-        entry.language = lang
-        yield entry
-
-    def test(self):
-        params = dict()
-        results = list()
-        for i in range(100):
-            res = next(self.analyse_entry(Entry(nif__isString="Hello"), params))
-            res.validate()
-            results.append(res.sentiments[0]['marl:hasPolarity'])
-        assert 'marl:Positive' in results
-        assert 'marl:Negative' in results

senpy/plugins/example/rand/rand.senpy

@@ -1,10 +0,0 @@
----
-name: rand
-module: rand
-description: A sample plugin that returns a random sentiment annotation
-author: "@balkian"
-version: '0.1'
-url: "https://github.com/gsi-upm/senpy-plugins-community"
-requirements: {}
-marl:maxPolarityValue: '1'
-marl:minPolarityValue: "-1"

senpy/plugins/misc/split.senpy

@@ -1,19 +0,0 @@
----
-name: split
-module: senpy.plugins.misc.split
-description: A sample plugin that chunks input text
-author: "@militarpancho"
-version: '0.2'
-url: "https://github.com/gsi-upm/senpy"
-requirements:
-    - nltk
-extra_params:
-  delimiter:
-    aliases:
-    - type
-    - t
-    required: false
-    default: sentence
-    options:
-    - sentence
-    - paragraph

senpy/plugins/misc/split_plugin.py

@@ -1,29 +1,51 @@
-from senpy.plugins import AnalysisPlugin
+from senpy.plugins import Transformation
 from senpy.models import Entry
 from nltk.tokenize.punkt import PunktSentenceTokenizer
 from nltk.tokenize.simple import LineTokenizer
-import nltk
 
 
-class SplitPlugin(AnalysisPlugin):
+class Split(Transformation):
+    '''
+    A plugin that chunks input text, into paragraphs or sentences.
 
-    def activate(self):
-        nltk.download('punkt')
+    It does not provide any sort of annotation, and it is meant to precede
+    other annotation plugins, when the annotation of individual sentences
+    (or paragraphs) is required.
+    '''
 
-    def analyse_entry(self, entry, params):
-        chunker_type = params.get("delimiter", "sentence")
+    author = ["@militarpancho", '@balkian']
+    version = '0.3'
+    url = "https://github.com/gsi-upm/senpy"
+    nltk_resources = ['punkt']
+
+    extra_params = {
+        'delimiter': {
+            'description': 'Split text into paragraphs or sentences.',
+            'aliases': ['type', 't'],
+            'required': False,
+            'default': 'sentence',
+            'options': ['sentence', 'paragraph']
+        },
+    }
+
+    def analyse_entry(self, entry, activity):
+        yield entry
+        chunker_type = activity.params["delimiter"]
         original_text = entry['nif:isString']
         if chunker_type == "sentence":
             tokenizer = PunktSentenceTokenizer()
         if chunker_type == "paragraph":
             tokenizer = LineTokenizer()
         chars = list(tokenizer.span_tokenize(original_text))
-        for i, chunk in enumerate(tokenizer.tokenize(original_text)):
-            print(chunk)
+        if len(chars) == 1:
+            # This sentence was already split
+            return
+        for i, chunk in enumerate(chars):
+            start, end = chunk
             e = Entry()
-            e['nif:isString'] = chunk
+            e['nif:isString'] = original_text[start:end]
             if entry.id:
-                e.id = entry.id + "#char={},{}".format(chars[i][0], chars[i][1])
+                e.id = entry.id + "#char={},{}".format(start, end)
             yield e
 
     test_cases = [
@@ -45,7 +67,7 @@ class SplitPlugin(AnalysisPlugin):
         },
         {
             'entry': {
-                "id": ":test",
+                "@id": ":test",
                 'nif:isString': 'Hello\nWorld'
             },
             'params': {