New Release: 0.9.0

.github/workflows/docs.yml

@@ -6,6 +6,8 @@ on:
      - master
      - documentation # only for quick updates or testing purposes
   pull_request:
+    branches:
+      - master
 
 jobs:
   docs:
@@ -51,7 +53,7 @@ jobs:
       uses: nwtgck/actions-netlify@v1.2
       with:
         publish-dir: 'docs/_build/html'
-        production-branch: develop
+        production-branch: master
         github-token: ${{ secrets.GITHUB_TOKEN }}
         deploy-message: "Deploy from GitHub Actions ${{ github.sha }}"
         alias: ${{ github.head_ref }}

.github/workflows/test.yml

@@ -24,17 +24,16 @@ jobs:
         run: |
           ruff check ontolearn/learners/ --line-length=200
 
-      - name: Test with pytest
+      - name: Get external files
         run: |
           wget https://files.dice-research.org/projects/Ontolearn/KGs.zip
           wget https://files.dice-research.org/projects/Ontolearn/LPs.zip
           wget https://files.dice-research.org/projects/Ontolearn/CLIP/CLIPData.zip
           wget https://files.dice-research.org/projects/NCES/NCES_Ontolearn_Data/NCESData.zip
           unzip KGs.zip && unzip LPs.zip && unzip NCESData.zip && unzip CLIPData.zip
-          pytest -p no:warnings -x
 
-      - name: Coverage report
+      - name: Testing and coverage report
         run: | 
           pip install coverage
-          coverage run -m pytest
-          coverage report -m
+          coverage run -m pytest -p no:warnings -x
+          coverage report -m

docs/index.rst

@@ -11,6 +11,7 @@ Ontolearn is an open-source software library for explainable structured machine
    usage/02_installation
    usage/03_examples
    usage/04_knowledge_base
+   usage/05_evaluate_ce
    usage/06_concept_learners
    usage/09_further_resources
    autoapi/ontolearn/index

docs/usage/01_introduction.md

@@ -1,49 +1,46 @@
 # About Ontolearn
 
-**Version:** ontolearn 0.8.1
+**Version:** ontolearn 0.9.0
 
 **GitHub repository:** [https://github.com/dice-group/Ontolearn](https://github.com/dice-group/Ontolearn)
 
 **Publisher and maintainer:** [DICE](https://dice-research.org/) - data science research group of [Paderborn University](https://www.uni-paderborn.de/en/university).
 
-**Contact**: [onto-learn@lists.uni-paderborn.de](mailto:onto-learn@lists.uni-paderborn.de)
+**Contact**: [cdemir@mail.uni-paderborn.de](mailto:cdemir@mail.uni-paderborn.de), [alkid@mail.uni-paderborn.de](mailto:alkid@mail.uni-paderborn.de)
 
 **License:** MIT License
 
 --------------------------------------------------------------------------------------------
 
-Ontolearn is an open-source software library for explainable structured machine learning in Python.
+OntoLearn is an open-source software library designed for explainable structured machine learning in OWL 2.0 ontologies.
+Our primary objective is to leverage structured learning techniques within the OWL framework, providing a robust and 
+interpretable approach to ontology-based machine learning.
 
-Ontolearn started with the goal of using _Explainable Structured Machine Learning_ 
-in OWL 2.0 ontologies and this
-exactly what our library offers. The main contribution are the exclusive concept learning
-algorithms that are part of this library. Currently, we have 6 fully functioning algorithms that 
-learn concept in description logics. Papers can be found [here](09_further_resources.md).
+One of OntoLearn’s key contributions is its exclusive concept learning algorithms, specifically tailored for Description 
+Logics (DL). The library currently includes nine fully functional algorithms capable of learning complex concepts in DL. 
+For further details and references, relevant research papers can be found [here](09_further_resources.md).
 
-For the base (core) module of Ontolearn we use [owlapy](https://github.com/dice-group/owlapy)
-which on its end uses [Owlready2](https://owlready2.readthedocs.io/en/latest/index.html). _Owlapy_ is a python package
-based on owlapi (the java counterpart), and implemented by us, the Ontolearn team. 
-For the sake of modularization we have moved it in a separate repository.
-The modularization aspect helps us to increase readability and reduce complexity.
-So now we use owlapy not only for OWL 2 entities representation but
-for ontology manipulation and reasoning as well.
+At the core of OntoLearn lies [Owlapy]((https://github.com/dice-group/owlapy)), a Python package inspired by the OWL API (its Java counterpart) and developed by 
+the OntoLearn team. To enhance modularity, readability, and maintainability, we have separated Owlapy from Ontolearn into an 
+independent repository. This modular approach allows Owlapy to serve not only as a framework for representing OWL 2 
+entities, but also as a tool for ontology manipulation and reasoning.
 
 ---------------------------------------
 
 **Ontolearn (including owlapy and ontosample) can do the following:**
 
-- Load/save ontologies in RDF/XML, OWL/XML.
+- **Use concept learning algorithms to generate hypotheses for classifying positive examples in a learning problem**.
+- **Use local datasets or datasets that are hosted on a triplestore server, for the learning task.**
+- Construct/Generate class expressions and evaluate them using different metrics.
+- Define learning problems.
+- Load/create/save ontologies in RDF/XML, OWL/XML.
 - Modify ontologies by adding/removing axioms.
 - Access individuals/classes/properties of an ontology (and a lot more).
-- Define learning problems.
-- Sample ontologies.
-- Construct class expressions.
-- Use concept learning algorithms to classify positive examples in a learning problem.
-- Use local datasets or datasets that are hosted on a triplestore server, for the learning task.
 - Reason over an ontology.
-- Other convenient functionalities like converting OWL class expressions to SPARQL or DL syntax.
+- Convenient functionalities like converting OWL class expressions to SPARQL or DL syntax.
+- Sample ontologies.
 
 ------------------------------------
 
 The rest of content after "examples" is build as a top-to-bottom guide, but nevertheless self-containing, where
-you can learn more in depth about the capabilities of Ontolearn.
+you can learn more in depth about the components of Ontolearn.

docs/usage/02_installation.md

@@ -1,12 +1,12 @@
 # Installation
 
-Since Ontolearn is a Python library, you will need to have Python on
-your system. Python comes in various versions and with different,
-sometimes conflicting dependencies. Hence, most guides will recommend
-to set up a "virtual environment" to work in.
+Since Ontolearn is a Python library, you will need to have Python installed on
+your system (currently supporting version 3.10.13 or higher). Since python comes in various 
+versions and with different, sometimes conflicting dependencies, most guides will 
+recommend to set up a "virtual environment" to work in and so do we.
 
-One such system for virtual python environments is 
-[conda](https://conda.io/projects/conda/en/latest/index.html).
+To create a virtual python environments you can consider using the builtin python module
+[venv](https://docs.python.org/3/library/venv.html) or [conda](https://conda.io/projects/conda/en/latest/index.html). 
 
 ## Installation via _pip_
 
@@ -71,18 +71,15 @@ to successfully pass all the tests:
 ```shell
 pytest
 ```
-Note: Since Unix and Windows reference files differently, the test are set to work on Linux 
-but in Widows the filepaths throughout test cases should be changed which is something that
-is not very convenient to do. If you really want to run the tests in Windows, you can
-make use of the replace all functionality to change them.
+Note: The tests are designed to run successfully on Linux machines since we also use them in 
+GitHub Action. Therefore, trying to run them on a Windows machine can lead to some issues.
 
 ## Download External Files
 
 Some resources like pre-calculated embeddings or `pre_trained_agents` and datasets (ontologies)
-are not included in the repository directly. Use the command line command `wget`
-to download them from our data server.
+are not included in the repository directly. Use the command `wget` to download them from our data server.
 
-> **NOTE: Before you run this commands in your terminal, make sure you are 
+> **NOTE: Before you run the following commands in your terminal, make sure you are 
 in the root directory of the project!**
 
 To download the datasets:
@@ -109,31 +106,33 @@ Finally, remove the _.zip_ file:
 rm KGs.zip
 ```
 
---------------------------------------------------------
-
-### NCES data: 
+To download learning problems:
 
 ```shell
-wget https://files.dice-research.org/projects/NCES/NCES_Ontolearn_Data/NCESData.zip -O ./NCESData.zip
-unzip NCESData.zip
-rm NCESData.zip
+wget https://files.dice-research.org/projects/Ontolearn/LPs.zip
 ```
 
-If you are getting any error check if the following flags can help:
+Follow the same steps to unzip as the in the KGs case.
+
+--------------------------------------------------------
+
+### Other Data
+Below you will find the links to get the necesseray data for _NCES_, _NCES2_, _ROCES_ and _CLIP_.
+The process to extract the data is the same as shown earlier with "KGs".
 
-```shell
-unzip -o NCESData.zip
-rm -f NCESData.zip
 ```
 
--------------------------------------------------------
+#NCES:
+https://files.dice-research.org/projects/NCES/NCES_Ontolearn_Data/NCESData.zip
 
-### CLIP data:
+#NCES2:
+https://files.dice-research.org/projects/NCES/NCES_Ontolearn_Data/NCES2Data.zip
 
-```commandline
-wget https://files.dice-research.org/projects/Ontolearn/CLIP/CLIPData.zip
-unzip CLIPData.zip
-rm CLIPData.zip 
+#ROCES:
+https://files.dice-research.org/projects/NCES/NCES_Ontolearn_Data/ROCESData.zip
+
+#CLIP:
+https://files.dice-research.org/projects/Ontolearn/CLIP/CLIPData.zip
 ```
 
 ## Building (sdist and bdist_wheel)
@@ -143,11 +142,18 @@ it is necessary to use the `build` tool. It can be invoked with:
 
 ```shell
 python -m build
+
+# or
+
+python setup.py bdist_wheel sdist
 ```
 
-from the main source code folder. Packages created by `build` can then
-be uploaded as releases to the [Python Package Index (PyPI)](https://pypi.org/) using
-[twine](https://pypi.org/project/twine/).
+Distribution packages that are created, can then
+be published to the [Python Package Index (PyPI)](https://pypi.org/) using [twine](https://pypi.org/project/twine/).
+
+```shell
+py -m twine upload --repository pypi dist/*
+```
 
 
 ### Building the docs
@@ -167,12 +173,17 @@ sphinx-build -M latex docs/ docs/_build/
 
 ## Simple Linting
 
-Using the following command will run the linting tool [flake8](https://flake8.pycqa.org/) on the source code.
+You can lint check using [flake8](https://flake8.pycqa.org/):
 ```shell
 flake8
 ```
 
-Additionally, you can specify the path where you want to flake8 to run.
+or ruff:
+```shell
+ruff check
+```
+
+Additionally, you can specify the path where you want to execute the linter.
 
 
 ----------------------------------------------------------------------

docs/usage/03_examples.md

@@ -2,7 +2,7 @@
 
 In this guide we will show some non-trival examples of typical use-cases of Ontolearn
 which you can also find in the
-[examples](https://github.com/dice-group/Ontolearn/tree/develop/examples) folder.
+[examples](https://github.com/dice-group/Ontolearn/tree/master/examples) folder.
 
 
 ## Ex. 1: Learning Over a Local Ontology
@@ -133,7 +133,7 @@ save_owl_class_expressions(expressions=h, path="owl_prediction")
 Here we have used the triplestore endpoint as you see in step _(1)_ which is
 available only on a private network. However, you can host your own triplestore
 server following [this guide](06_concept_learners.md#loading-and-launching-a-triplestore)
-and run TDL using you own local endpoint.
+and run TDL using you own local endpoint. We have a [script](https://github.com/dice-group/Ontolearn/blob/master/examples/concept_learning_via_triplestore_example.py) for that also.
 
 --------------------------------------------------------------
 
@@ -263,6 +263,6 @@ if __name__ == '__main__':
 
 -----------------------------------------------------------
 
-In the next guide we will explore the [KnowledgeBase](ontolearn.knowledge_base.KnowledgeBase) class that is needed to 
+In the next guide we will explore the [KnowledgeBase](ontolearn.knowledge_base.KnowledgeBase) class which is needed to 
 run a concept learner.