inception-reports 0.1__tar.gz

inception_reports-0.1/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

inception_reports-0.1/NOTICE.txt

@@ -0,0 +1,15 @@
+The copyright of the code in this repository belongs to the respective contributors who
+license their contribution under the terms of the Apache License 2.0.
+
+Besides individual contributions, the copyright in this codebase largely belongs to:
+
+Copyright 2018-2021 Ubiquitous Knowledge Processing (UKP) Lab
+                    Technische Universität Darmstadt
+                    (in the context of the INCEpTION project)
+
+Copyright 2012-2016 Ubiquitous Knowledge Processing (UKP) Lab and FG Language Technology
+                    Technische Universität Darmstadt
+                    (in the context of the WebAnno project(s))
+
+For individual contributions, please check the CONTRIBITORS.txt file as well as the history
+contained in this repository.

inception_reports-0.1/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.1
+Name: inception_reports
+Version: 0.1
+Summary: Generate plots that report the progress of an INCEpTION project.
+Author-email: Serwar Basch <serwar.basch@tu-darmstadt.de>
+Project-URL: Homepage, https://github.com/inception-project/inception-reporting-dashboard
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE.txt
+Requires-Dist: streamlit
+Requires-Dist: pandas
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: dkpro-cassis
+Requires-Dist: pycaprio
+
+# INCEpTION Reporting Dashboard
+
+This package will generate plots to track the progress of your INCEpTION project(s).
+
+In its current state, it can be used by the project manager on site to visualize different metrics regarding the progress of the project, and the type of annotations done.
+
+In case the project is part of a bigger project, the project progress can be exported to be sent to a project lead in a centralized location who, in turn, can use the package to get an overview of the progress across the different projects and locations.
+
+## Getting started
+
+1. Ensure you have python 3.11 or higher (check it using python --version)
+2. Install the package using ``pip install inception_reports``
+3. Run the script using ``inception_reports --help`` this will show you the options you have:
+    1. Run it with ``inception_reports --manager`` if you have one python project, or are responsible for one location.
+    2. Run it with ``inception_reports --lead`` if you're leading multiple projects, or multiple locations.
+4. Regardless of the mode you run the package with, it should open a browser window. Follow the instructions on the page to proceed.
+
+## Issues
+
+This package is under early developments, if you notice any bugs, or face any issues, do not hesitate to open a [Github issue](https://github.com/inception-project/inception-reporting-dashboard/issues).

inception_reports-0.1/README.md

@@ -0,0 +1,20 @@
+# INCEpTION Reporting Dashboard
+
+This package will generate plots to track the progress of your INCEpTION project(s).
+
+In its current state, it can be used by the project manager on site to visualize different metrics regarding the progress of the project, and the type of annotations done.
+
+In case the project is part of a bigger project, the project progress can be exported to be sent to a project lead in a centralized location who, in turn, can use the package to get an overview of the progress across the different projects and locations.
+
+## Getting started
+
+1. Ensure you have python 3.11 or higher (check it using python --version)
+2. Install the package using ``pip install inception_reports``
+3. Run the script using ``inception_reports --help`` this will show you the options you have:
+    1. Run it with ``inception_reports --manager`` if you have one python project, or are responsible for one location.
+    2. Run it with ``inception_reports --lead`` if you're leading multiple projects, or multiple locations.
+4. Regardless of the mode you run the package with, it should open a browser window. Follow the instructions on the page to proceed.
+
+## Issues
+
+This package is under early developments, if you notice any bugs, or face any issues, do not hesitate to open a [Github issue](https://github.com/inception-project/inception-reporting-dashboard/issues).

inception_reports-0.1/inception_reports/__init__.py

@@ -0,0 +1,15 @@
+# Licensed to the Technische Universität Darmstadt under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The Technische Universität Darmstadt 
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.
+ 
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

inception_reports-0.1/inception_reports/__main__.py

@@ -0,0 +1,47 @@
+# Licensed to the Technische Universität Darmstadt under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The Technische Universität Darmstadt
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import sys
+import argparse
+from streamlit.web import cli
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate plots for your INCEpTION project."
+    )
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument(
+        "--manager", help="You are managing a single project, or a single location.", action="store_true"
+    )
+    group.add_argument("--lead", help="You are leading multiple projects, or multiple locations.", action="store_true")
+
+    args = parser.parse_args()
+
+    if args.manager:
+        sys.argv = [
+            "streamlit",
+            "run",
+            f"{os.path.dirname(os.path.realpath(__file__))}/generate_reports_manager.py",
+        ]
+    elif args.lead:
+        sys.argv = [
+            "streamlit",
+            "run",
+            f"{os.path.dirname(os.path.realpath(__file__))}/generate_reports_lead.py",
+        ]
+    sys.exit(cli.main())

inception_reports-0.1/inception_reports/generate_reports_lead.py

@@ -0,0 +1,231 @@
+# Licensed to the Technische Universität Darmstadt under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The Technische Universität Darmstadt
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+import os
+import warnings
+
+import matplotlib.pyplot as plt
+import numpy as np
+import streamlit as st
+
+# suppress deprecation warnings related to the use of the pyplot
+# can be solved by sending the fig instead of the plt to streamlit
+st.set_option("deprecation.showPyplotGlobalUse", False)
+st.set_page_config(page_title="INCEpTION Reporting Dashboard", layout="centered")
+warnings.filterwarnings("ignore", message="Boolean Series key will be reindexed to match DataFrame index")
+
+
+def change_width(page_width=80) -> None:
+    css=f'''
+    <style>
+    section.main > div {{max-width:{page_width}%}}
+    </style>
+    '''
+    st.markdown(css, unsafe_allow_html=True)
+
+def plot_multiples(projects, tag) -> None:
+
+    st.title(f"Projects with tag: {tag}")
+    plt.figure(figsize=(30, 6), dpi=800)
+
+    pie_labels = [
+        "New",
+        "Annotation In Progress",
+        "Annotation Finished",
+        "Curation In Progress",
+        "Curation Finished",
+    ]
+    pie_colors = [
+        'tab:red',
+        'cornflowerblue',
+        'royalblue',
+        'limegreen',
+        'forestgreen',
+    ]
+
+    for idx, project in enumerate(projects):
+        plt.subplot(1, len(projects), idx+1)
+        plt.title(project["project_name"].split(".")[0], fontsize=22, fontweight="bold")
+        data_sizes = [
+            project["doc_categories"]["NEW"],
+            project["doc_categories"]["ANNOTATION_IN_PROGRESS"],
+            project["doc_categories"]["ANNOTATION_FINISHED"],
+            project["doc_categories"]["CURATION_IN_PROGRESS"],
+            project["doc_categories"]["CURATION_FINISHED"],
+        ]
+
+        pie_percentages = 100.0 * np.array(data_sizes) / np.array(data_sizes).sum()
+
+        wedges, _ = plt.pie(
+            data_sizes,
+            colors=pie_colors,
+            startangle=90,
+            radius=2,
+            counterclock=False
+            )
+
+        plt.axis("equal")
+
+        legend_labels = [
+            f"{label} ({percent:.2f}% / {size} files)"
+            for label, size, percent in zip(pie_labels, data_sizes, pie_percentages)
+        ]
+        plt.legend(
+            wedges,
+            legend_labels,
+            title="Categories",
+            fontsize=12,
+            loc="center left",
+            bbox_to_anchor=(1, 0.5),
+        )
+
+    plt.tight_layout()
+    st.pyplot()
+
+
+def plot_project_progress(project_data, multiple=False) -> None:
+    """
+    Generate a visual representation of project progress based on an export of project details provided by the site manager.
+
+    This function takes a dict containing project progress data and generates a pie chart showing the percentage of files finished vs. remaining.
+
+
+    Parameters:
+        project_data (dict): A dictionary containing project progress data.
+
+    """
+    st.title(f"Project: {project_data['project_name'].split('.')[0]}")
+
+    data_sizes = [
+        project_data["doc_categories"]["NEW"],
+        project_data["doc_categories"]["ANNOTATION_IN_PROGRESS"],
+        project_data["doc_categories"]["ANNOTATION_FINISHED"],
+        project_data["doc_categories"]["CURATION_IN_PROGRESS"],
+        project_data["doc_categories"]["CURATION_FINISHED"],
+    ]
+
+    pie_labels = [
+        "New",
+        "Annotation In Progress",
+        "Annotation Finished",
+        "Curation In Progress",
+        "Curation Finished",
+    ]
+    pie_colors = [
+        "#fc1c03",
+        "#fcbe03",
+        "#03fc17",
+        "#0373fc",
+        "#4e03fc",
+    ]
+    pie_percentages = 100.0 * np.array(data_sizes) / np.array(data_sizes).sum()
+    plt.figure(figsize=(15, 9))
+    plt.suptitle(f"Documents' Status\n{project_data['project_tags'][-1].upper()}", fontsize=16, fontweight="bold")
+    wedges, texts = plt.pie(
+        data_sizes,
+        colors=pie_colors,
+        startangle=140)
+
+    plt.axis("equal")
+
+    # Create a legend with labels and percentages
+    legend_labels = [
+        f"{label} ({percent:.2f}% / {size} files)"
+        for label, size, percent in zip(pie_labels, data_sizes, pie_percentages)
+    ]
+    plt.legend(
+        wedges,
+        legend_labels,
+        title="Categories",
+        fontsize=12,
+        loc="center left",
+        bbox_to_anchor=(1, 0.5),
+    )
+    plt.tight_layout()
+    st.pyplot()
+
+def read_dir(dir) -> list[dict]:
+    """
+    Read a file and return a pandas dataframe, regardless of the file type.
+
+    Parameters:
+        dir (str): The dir of INCEpTION projects progress data.
+
+    Returns
+        List[dict]: A list of dicts containing the project progress data as json files.
+    """
+    projects = []
+
+    for file in os.listdir(dir):
+        projects.append(json.load(open(os.path.join(dir, file), "r")))
+    return projects
+
+def get_unique_tags(projects):
+    """
+    Get a list of unique tags from a list of projects.
+
+    Args:
+        projects (list): A list of projects.
+
+    Returns:
+        list: A list of unique tags extracted from the projects.
+    """
+    unique_tags = set()
+    for project in projects:
+        unique_tags.update(project.get('project_tags', []))
+    return list(unique_tags)
+
+
+def select_data_folder():
+    """
+    Generate a sidebar widget to select the data folder containing the INCEpTION projects.
+    """
+
+    st.sidebar.write("Please input the path to the folder containing the INCEpTION projects.")
+    projects_folder = st.sidebar.text_input("Projects Folder:", value="")
+    if st.sidebar.button("Generate Reports"):
+        st.session_state['initialized'] = True
+        st.session_state['projects_folder'] = projects_folder
+
+def main():
+    change_width(80)
+    st.title("INCEpTION Projects Progress")
+
+    select_data_folder()
+
+    projects = []
+    if 'projects_folder' in st.session_state:
+        projects = read_dir(st.session_state.projects_folder)
+        projects.sort(key=lambda x: x["project_name"])
+
+    if projects:
+        unique_tags = get_unique_tags(projects)
+        
+        selected_tags = []
+        columns = st.columns(len(unique_tags))
+
+        for col, tag in zip(columns, unique_tags):
+            if col.checkbox(tag.capitalize(), key=tag):
+                selected_tags.append(tag)
+
+        for tag in selected_tags:
+            multi_projects = [project for project in projects if tag in project["project_tags"]]
+            plot_multiples(multi_projects, tag)
+
+
+if __name__ == "__main__":
+    main()

inception_reports-0.1/inception_reports/generate_reports_manager.py

@@ -0,0 +1,373 @@
+# Licensed to the Technische Universität Darmstadt under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The Technische Universität Darmstadt
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+import os
+import shutil
+import warnings
+import zipfile
+
+import cassis
+import matplotlib.pyplot as plt
+import numpy as np
+import streamlit as st
+from matplotlib import gridspec
+from pycaprio import Pycaprio
+
+# suppress deprecation warnings related to the use of the pyplot
+# can be solved by sending the fig instead of the plt to streamlit
+st.set_option("deprecation.showPyplotGlobalUse", False)
+st.set_page_config(page_title="INCEpTION Reporting Dashboard", layout="centered")
+css = """
+<style>
+    section.main > div {max-width:50%}
+</style>
+"""
+st.markdown(css, unsafe_allow_html=True)
+warnings.filterwarnings(
+    "ignore", message="Boolean Series key will be reindexed to match DataFrame index"
+)
+
+
+def plot_project_progress(project) -> None:
+    """
+    Generate a visual representation of project progress based on a DataFrame of log data.
+
+    This function takes a DataFrame containing log data and generates
+    visualizations to represent the progress of different documents. It calculates the
+    total time spent on each document, divides it into sessions based on a specified
+    threshold, and displays a pie chart showing the percentage of finished and remaining
+    documents, along with a bar chart showing the total time spent on finished documents
+    compared to the estimated time for remaining documents.
+
+    Parameters:
+        project (dict): A dict containing project information, namely the name, tags, annotations, and logs.
+
+    """
+
+    # df = project["logs"]
+    project_name = project["name"]
+    project_tags = project["tags"]
+    project_annotations = project["annotations"]
+    project_documents = project["documents"]
+
+    doc_categories = {
+        "ANNOTATION_IN_PROGRESS": 0,
+        "ANNOTATION_FINISHED": 0,
+        "CURATION_IN_PROGRESS": 0,
+        "CURATION_FINISHED": 0,
+        "NEW": 0,
+    }
+
+    for doc in project_documents:
+        state = doc["state"]
+        if state in doc_categories:
+            doc_categories[state] += 1
+
+    project_data = {
+        "project_name": project_name,
+        "project_tags": project_tags,
+        "doc_categories": doc_categories,
+    }
+
+
+
+    type_counts = get_type_counts(project_annotations)
+    selected_annotation_types = st.multiselect(
+        f"Which annotation types would you like to see for {project_name}?",
+        list(type_counts.keys()),
+        list(type_counts.keys())
+    )
+    type_counts = {k: v for k, v in type_counts.items() if k in selected_annotation_types}
+
+    data_sizes = [
+        project_data["doc_categories"]["NEW"],
+        project_data["doc_categories"]["ANNOTATION_IN_PROGRESS"],
+        project_data["doc_categories"]["ANNOTATION_FINISHED"],
+        project_data["doc_categories"]["CURATION_IN_PROGRESS"],
+        project_data["doc_categories"]["CURATION_FINISHED"],
+    ]
+
+    pie_labels = [
+        "New",
+        "Annotation In Progress",
+        "Annotation Finished",
+        "Curation In Progress",
+        "Curation Finished",
+    ]
+    pie_colors = [
+        "tab:red",
+        "cornflowerblue",
+        "royalblue",
+        "limegreen",
+        "forestgreen",
+    ]
+    pie_percentages = 100.0 * np.array(data_sizes) / np.array(data_sizes).sum()
+    fig = plt.figure(figsize=(15, 9))
+    gs = gridspec.GridSpec(1, 3, width_ratios=[1, 0.01, 1])
+
+    ax1 = plt.subplot(gs[0])
+
+    wedges, _ = ax1.pie(
+        data_sizes, colors=pie_colors, startangle=90, radius=2, counterclock=False
+    )
+
+    ax1.axis("equal")
+    total_annotations = sum(
+        [len(cas_file.select_all()) for cas_file in project_annotations.values()]
+    )
+    ax1.set_title("Documents Status")
+
+    legend_labels = [
+        f"{label} ({percent:.2f}% / {size} files)"
+        for label, size, percent in zip(pie_labels, data_sizes, pie_percentages)
+    ]
+    ax1.legend(
+        wedges,
+        legend_labels,
+        title="Categories",
+        loc="center left",
+        bbox_to_anchor=(1, 0.5),
+    )
+
+    ax2 = plt.subplot(gs[2])
+    colors = plt.cm.tab10(range(len(type_counts.keys())))
+    ax2.set_title("Types of Annotations")
+    ax2.barh(
+        [f"{type} = {value}" for type, value in type_counts.items()],
+        list(type_counts.values()),
+        color=colors,
+    )
+    ax2.set_xlabel("Number of Annotations")
+    
+    fig.suptitle(
+        f'{project_name.split(".")[0]}\nTotal Annotations: {total_annotations}',
+        fontsize=16,
+    )
+    fig.tight_layout()
+    st.pyplot()
+
+    # st.title(f"Project: {project_name.split('.')[0]}")
+    if st.button(f"Export data for {project_name.split('.')[0]}"):
+        with open(f"{project_name.split('.')[0]}_data.json", "w") as output_file:
+            output_file.write(json.dumps(project_data, indent=4))
+        st.success(f"{project_name.split('.')[0]} data exported successfully ✅")
+
+
+def find_element_by_name(element_list, name):
+    """
+    Finds an element in the given element list by its name.
+
+    Args:
+        element_list (list): A list of elements to search through.
+        name (str): The name of the element to find.
+
+    Returns:
+        str: The UI name of the found element, or the last part of the name if not found.
+    """
+    for element in element_list:
+        if element.name == name:
+            return element.uiName
+    return name.split(".")[-1]
+
+
+def get_type_counts(annotations):
+    """
+    Calculate the count of each type in the given annotations. Each annotation is a CAS object.
+
+    Args:
+        annotations (dict): A dictionary containing the annotations.
+
+    Returns:
+        dict: A dictionary containing the count of each type.
+    """
+    count_dict = {}
+
+    layerDefinition = annotations.popitem()[1].select(
+        "de.tudarmstadt.ukp.clarin.webanno.api.type.LayerDefinition"
+    )
+    for doc in annotations:
+        type_names = [
+            (
+                find_element_by_name(layerDefinition, t.name),
+                len(annotations[doc].select(t.name)),
+            )
+            for t in annotations[doc].typesystem.get_types()
+            if t.name != "de.tudarmstadt.ukp.clarin.webanno.api.type.LayerDefinition"
+        ]
+
+        for type_name, count in type_names:
+            if type_name not in count_dict:
+                count_dict[type_name] = 0
+            count_dict[type_name] += count
+    count_dict = {k: v for k, v in count_dict.items() if v > 0}
+    count_dict = dict(sorted(count_dict.items(), key=lambda item: item[1]))
+
+    return count_dict
+
+
+def read_dir(dir_path: str) -> list[dict]:
+    """
+    Reads a directory containing zip files, extracts the contents, and retrieves project metadata and annotations.
+
+    Args:
+        dir_path (str): The path to the directory containing the zip files.
+
+    Returns:
+        list[dict]: A list of dictionaries, where each dictionary represents a project and contains the following keys:
+            - "name": The name of the zip file.
+            - "tags": A list of tags extracted from the project metadata.
+            - "documents": A list of source documents from the project metadata.
+            - "annotations": A dictionary mapping annotation subfolder names to their corresponding CAS objects.
+    """
+    projects = []
+
+    for file_name in os.listdir(dir_path):
+        file_path = os.path.join(dir_path, file_name)
+        if zipfile.is_zipfile(file_path):
+            with zipfile.ZipFile(file_path, "r") as zip_file:
+                zip_path = f"{dir_path}/{file_name.split('.')[0]}"
+                zip_file.extractall(path=zip_path)
+
+                # Find project metadata file
+                project_meta_path = os.path.join(zip_path, "exportedproject.json")
+                if os.path.exists(project_meta_path):
+                    with open(project_meta_path, "r") as project_meta_file:
+                        project_meta = json.load(project_meta_file)
+                        project_tags = [
+                            word.strip("#")
+                            for word in project_meta["description"].split()
+                            if word.startswith("#")
+                        ]
+                        project_documents = project_meta["source_documents"]
+
+                annotations = {}
+                # Find annotation folders
+                annotation_folders = [
+                    name
+                    for name in zip_file.namelist()
+                    if name.startswith("annotation/")
+                    and name.endswith(".json")
+                    and not name.endswith("INITIAL_CAS.json")
+                ]
+                for annotation_file in annotation_folders:
+                    subfolder_name = os.path.dirname(annotation_file).split("/")[1]
+                    with zip_file.open(annotation_file) as cas_file:
+                        cas = cassis.load_cas_from_json(cas_file)
+                        annotations[subfolder_name] = cas
+
+                projects.append(
+                    {
+                        "name": file_name,
+                        "tags": project_tags,
+                        "documents": project_documents,
+                        "annotations": annotations,
+                    }
+                )
+
+                # Clean up extracted files
+                shutil.rmtree(zip_path)
+
+    return projects
+
+
+
+def login_to_inception(api_url, username, password):
+    """
+    Logs in to the Inception API using the provided API URL, username, and password.
+
+    Args:
+        api_url (str): The URL of the Inception API.
+        username (str): The username for authentication.
+        password (str): The password for authentication.
+
+    Returns:
+        tuple: A tuple containing a boolean value indicating whether the login was successful and an instance of the Inception client.
+
+    """
+    if "http" not in api_url:
+        api_url = f"http://{api_url}"
+    if st.sidebar.button("Login"):
+        inception_client = Pycaprio(api_url, (username, password))
+        st.sidebar.success("Login successful ✅")
+        return True, inception_client
+    return False, None
+
+
+
+def select_method_to_import_data():
+    """
+    Allows the user to select a method to import data for generating reports.
+    """
+    
+    method = st.sidebar.radio("Choose your method to import data:", ('Manually', 'API'), index=0)
+
+    if method == 'Manually':
+        st.sidebar.write("Please input the path to the folder containing the INCEpTION projects.")
+        projects_folder = st.sidebar.text_input("Projects Folder:", value="data/dresden_projects/")
+        if st.sidebar.button("Generate Reports"):
+            st.session_state['initialized'] = True
+            st.session_state['method'] = 'Manually'
+            st.session_state['projects_folder'] = projects_folder
+    elif method == 'API':
+        api_url = st.sidebar.text_input("Enter API URL:", "")
+        username = st.sidebar.text_input("Username:", "")
+        password = st.sidebar.text_input("Password:", type="password", value="")
+        inception_status, inception_client = login_to_inception(api_url, username, password)
+        if inception_status:
+            inception_projects = inception_client.api.projects()
+            st.sidebar.write("Following projects got imported:")
+            for inception_project in inception_projects:
+                st.sidebar.write(inception_project.project_name)
+                project_export = inception_client.api.export_project(inception_project, "jsoncas")
+                with open(f"{os.path.expanduser('~')}/.inception_reports/projects/{inception_project}.zip", "wb") as f:
+                    f.write(project_export)
+            st.session_state['initialized'] = True
+            st.session_state['method'] = 'API'
+            st.session_state['projects_folder'] = f"{os.path.expanduser('~')}/.inception_reports/projects"
+
+
+
+def create_directory_in_home():
+    """
+    Creates a directory in the user's home directory for storing Inception reports.
+    """
+    home_dir = os.path.expanduser("~")
+    new_dir_path = os.path.join(home_dir, ".inception_reports")
+    try:
+        os.makedirs(new_dir_path)
+        os.makedirs(os.path.join(new_dir_path, "projects"))
+    except FileExistsError:
+        pass
+
+
+def main():
+    create_directory_in_home()
+    
+    st.title("INCEpTION Projects Statistics")
+
+    if 'initialized' not in st.session_state:
+        select_method_to_import_data()
+
+    if 'method' in st.session_state:
+        projects = read_dir(st.session_state.projects_folder)
+        projects.sort(key=lambda x: x["name"])
+        for project in projects:
+            plot_project_progress(project)
+
+
+if __name__ == "__main__":
+    main()

inception_reports-0.1/inception_reports.egg-info/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.1
+Name: inception_reports
+Version: 0.1
+Summary: Generate plots that report the progress of an INCEpTION project.
+Author-email: Serwar Basch <serwar.basch@tu-darmstadt.de>
+Project-URL: Homepage, https://github.com/inception-project/inception-reporting-dashboard
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE.txt
+Requires-Dist: streamlit
+Requires-Dist: pandas
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: dkpro-cassis
+Requires-Dist: pycaprio
+
+# INCEpTION Reporting Dashboard
+
+This package will generate plots to track the progress of your INCEpTION project(s).
+
+In its current state, it can be used by the project manager on site to visualize different metrics regarding the progress of the project, and the type of annotations done.
+
+In case the project is part of a bigger project, the project progress can be exported to be sent to a project lead in a centralized location who, in turn, can use the package to get an overview of the progress across the different projects and locations.
+
+## Getting started
+
+1. Ensure you have python 3.11 or higher (check it using python --version)
+2. Install the package using ``pip install inception_reports``
+3. Run the script using ``inception_reports --help`` this will show you the options you have:
+    1. Run it with ``inception_reports --manager`` if you have one python project, or are responsible for one location.
+    2. Run it with ``inception_reports --lead`` if you're leading multiple projects, or multiple locations.
+4. Regardless of the mode you run the package with, it should open a browser window. Follow the instructions on the page to proceed.
+
+## Issues
+
+This package is under early developments, if you notice any bugs, or face any issues, do not hesitate to open a [Github issue](https://github.com/inception-project/inception-reporting-dashboard/issues).

inception_reports-0.1/inception_reports.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+NOTICE.txt
+README.md
+pyproject.toml
+inception_reports/__init__.py
+inception_reports/__main__.py
+inception_reports/generate_reports_lead.py
+inception_reports/generate_reports_manager.py
+inception_reports.egg-info/PKG-INFO
+inception_reports.egg-info/SOURCES.txt
+inception_reports.egg-info/dependency_links.txt
+inception_reports.egg-info/entry_points.txt
+inception_reports.egg-info/requires.txt
+inception_reports.egg-info/top_level.txt
+tests/test_generate_reports_lead.py
+tests/test_generate_reports_manager.py

inception_reports-0.1/inception_reports.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

inception_reports-0.1/inception_reports.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+inception_reports = inception_reports.__main__:main

inception_reports-0.1/inception_reports.egg-info/requires.txt

@@ -0,0 +1,6 @@
+streamlit
+pandas
+matplotlib
+numpy
+dkpro-cassis
+pycaprio

inception_reports-0.1/inception_reports.egg-info/top_level.txt

@@ -0,0 +1 @@
+inception_reports

inception_reports-0.1/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "inception_reports"
+description = "Generate plots that report the progress of an INCEpTION project."
+version = "0.1"
+authors = [
+    { name = "Serwar Basch", email = "serwar.basch@tu-darmstadt.de" }
+]
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "streamlit",
+    "pandas",
+    "matplotlib",
+    "numpy",
+    "dkpro-cassis",
+    "pycaprio",
+]
+
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: OS Independent",
+]
+
+[project.scripts]
+inception_reports = "inception_reports.__main__:main"
+
+[project.urls]
+Homepage = "https://github.com/inception-project/inception-reporting-dashboard"

inception_reports-0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

inception_reports-0.1/tests/test_generate_reports_lead.py

@@ -0,0 +1,111 @@
+# Licensed to the Technische Universität Darmstadt under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The Technische Universität Darmstadt
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+from unittest.mock import MagicMock, patch
+
+from inception_reports.generate_reports_lead import get_unique_tags, plot_project_progress, read_dir
+
+
+def test_get_unique_tags():
+    """
+    Test case for the get_unique_tags function.
+    
+    This test case verifies that the get_unique_tags function returns the expected result
+    when given a list of projects with tags.
+    """
+    projects = [
+        {"project_tags": ["tag1", "tag2"]},
+        {"project_tags": ["tag2", "tag3"]},
+        {"project_tags": ["tag3", "tag4"]},
+    ]
+    expected_result = ["tag1", "tag2", "tag3", "tag4"]
+    assert get_unique_tags(projects).sort() == expected_result.sort()
+
+
+def fake_json_loads(file):
+    """
+    Mimics json.load operation for a mocked file object.
+    This function will be called by json.load(mocked_open_instance).
+    """
+    return {
+        "project_name": "project_1",
+        "project_tags": ["tag1", "tag2", "tag3"],
+        "doc_categories": {
+            "ANNOTATION_IN_PROGRESS": 12,
+            "ANNOTATION_FINISHED": 5,
+            "CURATION_IN_PROGRESS": 0,
+            "CURATION_FINISHED": 0,
+            "NEW": 4,
+        },
+    }
+
+
+@patch("os.listdir", MagicMock(return_value=["project1.json"]))
+@patch("builtins.open", new_callable=MagicMock)
+@patch("json.load", MagicMock(side_effect=fake_json_loads))
+def test_read_dir(mock_open):
+    """
+    Test case for the read_dir function.
+
+    This test case verifies that the read_dir function correctly reads the contents of a directory and returns the expected result.
+
+    Args:
+        mock_open: A mock object for the built-in open function.
+
+    Returns:
+        None
+    """
+
+    dir = "some/dir"
+    expected = [
+        {
+            "project_name": "project_1",
+            "project_tags": ["tag1", "tag2", "tag3"],
+            "doc_categories": {
+                "ANNOTATION_IN_PROGRESS": 12,
+                "ANNOTATION_FINISHED": 5,
+                "CURATION_IN_PROGRESS": 0,
+                "CURATION_FINISHED": 0,
+                "NEW": 4,
+            },
+        }
+    ]
+
+    result = read_dir(dir)
+
+    mock_open.assert_called_once_with(os.path.join(dir, "project1.json"), "r")
+    assert result == expected, "Expected result does not match the actual result."
+
+
+def test_plot_project_progress():
+    """
+    Test case for the plot_project_progress function.
+    """
+    project_data = {
+        "project_name": "project_1",
+        "project_tags": ["tag1", "tag2", "tag3"],
+        "doc_categories": {
+            "ANNOTATION_IN_PROGRESS": 12,
+            "ANNOTATION_FINISHED": 5,
+            "CURATION_IN_PROGRESS": 0,
+            "CURATION_FINISHED": 0,
+            "NEW": 4,
+        },
+    }
+
+    plot_project_progress(project_data)
+    assert True, "Should not raise any exceptions"

inception_reports-0.1/tests/test_generate_reports_manager.py

@@ -0,0 +1,75 @@
+# Licensed to the Technische Universität Darmstadt under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The Technische Universität Darmstadt
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+import os
+import tempfile
+import zipfile
+from unittest.mock import Mock, patch
+
+from inception_reports.generate_reports_manager import find_element_by_name, read_dir
+
+
+def test_find_element_by_name():
+    MockElement_1 = Mock()
+    MockElement_1.configure_mock(**{"name": "element1", "uiName": "UI Element 1"})
+    MockElement_2 = Mock()
+    MockElement_2.configure_mock(**{"name": "element2", "uiName": "UI Element 2"})
+    MockElement_3 = Mock()
+    MockElement_3.configure_mock(**{"name": "element3", "uiName": "UI Element 3"})
+
+    element_list = [MockElement_1, MockElement_2, MockElement_3]
+
+    result = find_element_by_name(element_list, "element2")
+    assert result == "UI Element 2", "Should return the uiName of the found element"
+
+    result = find_element_by_name(element_list, "element4")
+    assert result == "element4", "Should return the last part of the name if not found"
+
+    result = find_element_by_name([], "element2")
+    assert result == "element2", "Should handle empty input list"
+
+
+
+@patch('cassis.load_cas_from_json', return_value="MockCASObject")
+@patch('os.listdir', return_value=['project1.zip'])
+@patch('zipfile.is_zipfile', return_value=True)
+@patch('shutil.rmtree')
+def test_read_dir_correctly_parses_zip_files(mock_rmtree, mock_is_zipfile, mock_listdir, mock_cas_loader):
+    with tempfile.TemporaryDirectory() as temp_dir:
+        zip_name = "project1.zip"
+        zip_path = os.path.join(temp_dir, zip_name)
+        with zipfile.ZipFile(zip_path, 'w') as zipf:
+            project_meta = {
+                "description": "A mock project #tag1 #tag2",
+                "source_documents": ["doc1.txt", "doc2.txt"]
+            }
+            zipf.writestr('exportedproject.json', json.dumps(project_meta))
+
+            annotation_content = {"dummy": "content"}
+            zipf.writestr('annotation/doc1/annotator1.json', json.dumps(annotation_content))
+
+        projects = read_dir(temp_dir)
+
+        assert len(projects) == 1, "Should correctly parse zip files and extract project data"
+        project = projects[0]
+        print(project['annotations'])
+        assert project['name'] == zip_name, "Project name should match the zip file name"
+        assert set(project['tags']) == {"tag1", "tag2"}, "Should extract correct tags from project metadata"
+        assert project['documents'] == ["doc1.txt", "doc2.txt"], "Should list all source documents"
+        assert 'doc1' in project['annotations'], "Should include annotations in the project data"
+        assert project['annotations']['doc1'] == "MockCASObject", "Should load CAS objects for annotations"
+