pyvalues 0.1.0__tar.gz

pyvalues-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ValueEval
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyvalues-0.1.0/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: pyvalues
+Version: 0.1.0
+Summary: Python library for processing, evaluating, and visualizing (Schwartz) human value scores
+License: MIT License
+         
+         Copyright (c) 2025 ValueEval
+         
+         Permission is hereby granted, free of charge, to any person obtaining a copy
+         of this software and associated documentation files (the "Software"), to deal
+         in the Software without restriction, including without limitation the rights
+         to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+         copies of the Software, and to permit persons to whom the Software is
+         furnished to do so, subject to the following conditions:
+         
+         The above copyright notice and this permission notice shall be included in all
+         copies or substantial portions of the Software.
+         
+         THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+         IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+         FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+         AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+         LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+         SOFTWARE.
+License-File: LICENSE
+Keywords: ai,artificial intelligence,classification,human values,schwartz values,vallueeval
+Author: Johannes Kiesel
+Maintainer: Johannes Kiesel
+Maintainer-email: Johannes.Kiesel@gesis.org
+Requires-Python: >=3.11,<3.15
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: matplotlib (>=3.10.8,<4.0.0)
+Requires-Dist: numpy (>=2.4.1,<3.0.0)
+Requires-Dist: pandas (>=2.3.3,<3.0.0)
+Requires-Dist: pydantic (>=2.12.3,<3.0.0)
+Project-URL: Issues, https://github.com/ValueEval/pyvalues/issues
+Project-URL: Source, https://github.com/ValueEval/pyvalues
+Description-Content-Type: text/markdown
+
+# pyvalues
+
+Python library for processing, evaluating, and visualizing (Schwartz) human value scores
+

pyvalues-0.1.0/README.md

@@ -0,0 +1,3 @@
+# pyvalues
+
+Python library for processing, evaluating, and visualizing (Schwartz) human value scores

pyvalues-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[project]
+name = "pyvalues"
+version = "0.1.0"
+description = "Python library for processing, evaluating, and visualizing (Schwartz) human value scores"
+requires-python = ">=3.11,<3.15"
+readme = "README.md"
+dependencies = [
+    "pandas (>=2.3.3,<3.0.0)",
+    "pydantic (>=2.12.3,<3.0.0)",
+    "matplotlib (>=3.10.8,<4.0.0)",
+    "numpy (>=2.4.1,<3.0.0)",
+]
+license = { file = "LICENSE" }
+keywords = [ "ai", "artificial intelligence", "classification", "human values", "schwartz values", "vallueeval" ]
+authors = [
+    {name = "Johannes Kiesel"},
+]
+maintainers = [
+    {name = "Johannes Kiesel",email = "Johannes.Kiesel@gesis.org"}
+]
+
+[project.urls]
+"Source" = "https://github.com/ValueEval/pyvalues"
+"Issues" = "https://github.com/ValueEval/pyvalues/issues"
+
+[tool.poetry]
+packages = [{include = "pyvalues", from = "src"}]
+
+[tool.poetry.group.development]
+optional = true
+[tool.poetry.group.development.dependencies]
+flake8 = "*"
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"

pyvalues-0.1.0/src/pyvalues/__init__.py

@@ -0,0 +1,35 @@
+from .values import (
+    RefinedValues,
+    RefinedCoarseValues,
+    OriginalValues,
+    RefinedValuesWithAttainment,
+    RefinedCoarseValuesWithAttainment,
+    OriginalValuesWithAttainment,
+)
+from .classifiers import (
+    RefinedValuesClassifier,
+    RefinedCoarseValuesClassifier,
+    OriginalValuesClassifier,
+    RefinedValuesWithAttainmentClassifier,
+    RefinedCoarseValuesWithAttainmentClassifier,
+    OriginalValuesWithAttainmentClassifier
+)
+
+__all__ = [
+    "RefinedValues",
+    "RefinedCoarseValues",
+    "OriginalValues",
+    "RefinedValuesWithAttainment",
+    "RefinedCoarseValuesWithAttainment",
+    "OriginalValuesWithAttainment",
+    "RefinedValuesClassifier",
+    "RefinedCoarseValuesClassifier",
+    "OriginalValuesClassifier",
+    "RefinedValuesWithAttainmentClassifier",
+    "RefinedCoarseValuesWithAttainmentClassifier",
+    "OriginalValuesWithAttainmentClassifier",
+]
+
+from importlib import metadata
+
+__version__ = metadata.version(__package__)  # type: ignore

pyvalues-0.1.0/src/pyvalues/classifiers.py

@@ -0,0 +1,109 @@
+from abc import ABC, abstractmethod
+
+from .values import (
+    RefinedValues,
+    RefinedCoarseValues,
+    OriginalValues,
+    RefinedValuesWithAttainment,
+    RefinedCoarseValuesWithAttainment,
+    OriginalValuesWithAttainment
+)
+
+
+class OriginalValuesClassifier(ABC):
+    """ Classifier for the ten values from Schwartz original system.
+    """
+
+    @abstractmethod
+    def classify_original_values(self, text: str, language: str = "EN") -> OriginalValues:
+        pass
+
+
+class RefinedCoarseValuesClassifier(OriginalValuesClassifier):
+    """ Classifier for the the twelve values from Schwartz refined system (19 values)
+    when combining values with same name prefix.
+    """
+
+    def classify_original_values(self, text: str, language: str = "EN") -> OriginalValues:
+        return self.classify_refined_coarse_values(text=text, language=language).original_values()
+
+    @abstractmethod
+    def classify_refined_coarse_values(self, text: str, language: str = "EN") -> RefinedCoarseValues:
+        pass
+
+
+class RefinedValuesClassifier(RefinedCoarseValuesClassifier):
+    """ Classifier for the 19 values from Schwartz refined system.
+    """
+
+    def classify_refined_coarse_values(self, text: str, language: str = "EN") -> RefinedCoarseValues:
+        return self.classify_refined_values(text=text, language=language).coarse_values()
+
+    @abstractmethod
+    def classify_refined_values(self, text: str, language: str = "EN") -> RefinedValues:
+        pass
+
+
+class OriginalValuesWithAttainmentClassifier(OriginalValuesClassifier):
+    """ Classifier for the ten values from Schwartz original system with attainment.
+    """
+
+    def classify_original_values(self, text: str, language: str = "EN") -> OriginalValues:
+        return self.classify_original_values_with_attainment(text=text, language=language).without_attainment()
+
+    @abstractmethod
+    def classify_original_values_with_attainment(
+        self,
+        text: str,
+        language: str = "EN"
+    ) -> OriginalValuesWithAttainment:
+        pass
+
+
+class RefinedCoarseValuesWithAttainmentClassifier(
+        OriginalValuesWithAttainmentClassifier, RefinedCoarseValuesClassifier):
+    """ Classifier for the the twelve values from Schwartz refined system (19 values)
+    when combining values with same name prefix and with attainment.
+    """
+
+    def classify_refined_coarse_values(
+        self, text: str, language: str = "EN"
+    ) -> RefinedCoarseValues:
+        return self.classify_refined_coarse_values_with_attainment(
+            text=text, language=language).without_attainment()
+
+    def classify_original_values_with_attainment(
+        self, text: str, language: str = "EN"
+    ) -> OriginalValuesWithAttainment:
+        return self.classify_refined_coarse_values_with_attainment(
+            text=text, language=language).original_values()
+
+    @abstractmethod
+    def classify_refined_coarse_values_with_attainment(
+        self, text: str, language: str = "EN"
+    ) -> RefinedCoarseValuesWithAttainment:
+        pass
+
+
+class RefinedValuesWithAttainmentClassifier(
+        RefinedCoarseValuesWithAttainmentClassifier, RefinedValuesClassifier):
+    """ Classifier for the 19 values from Schwartz refined system with attainment.
+    """
+
+    def classify_refined_values(
+        self, text: str, language: str = "EN"
+    ) -> RefinedValues:
+        return self.classify_refined_values_with_attainment(
+            text=text, language=language).without_attainment()
+
+    def classify_refined_coarse_values_with_attainment(
+        self, text: str, language: str = "EN"
+    ) -> RefinedCoarseValuesWithAttainment:
+        return self.classify_refined_values_with_attainment(
+            text=text, language=language).coarse_values()
+
+    @abstractmethod
+    def classify_refined_values_with_attainment(
+        self, text: str, language: str = "EN"
+    ) -> RefinedValuesWithAttainment:
+        pass

pyvalues-0.1.0/src/pyvalues/radarplot.py

@@ -0,0 +1,151 @@
+from matplotlib.lines import Line2D
+import matplotlib.pyplot as plt
+import numpy as np
+
+from matplotlib.patches import RegularPolygon
+from matplotlib.path import Path
+from matplotlib.projections import register_projection
+from matplotlib.projections.polar import PolarAxes
+from matplotlib.spines import Spine
+from matplotlib.transforms import Affine2D
+
+
+def plot_radar(
+    dim_names: list[str],
+    valuess: list[list[float]],
+    labels: list[str | None] = [None],
+    linecolors: list[str] = [
+        "#e41a1c",
+        "#377eb8",
+        "#4daf4a",
+        "#984ea3",
+        "#ff7f00",
+        "#ffff33",
+        "#a65628",
+        "#f781bf",
+        "#999999"
+    ],
+    fillcolors: list[str | None] = [None],
+    fillalphas: list[float] = [0.25]
+):
+    theta = radar_factory(len(dim_names))
+    fig, ax = plt.subplots(subplot_kw=dict(projection="radar"))
+    ax.set_ylim(0, 1)
+    ax.set_rgrids([0.25, 0.50, 0.75], fontsize="small")  # type: ignore
+    ax.set_varlabels(dim_names)  # type: ignore
+    has_label = False
+    for i in range(len(valuess)):
+        label = labels[i % len(labels)]
+        ax.plot(theta, list(valuess[i]),
+                color=linecolors[i % len(linecolors)],
+                label=label)
+        if fillcolors[i % len(fillcolors)] is not None:
+            ax.fill(theta, list(valuess[i]),
+                    facecolor=fillcolors[i % len(fillcolors)],
+                    alpha=fillalphas[i % len(fillalphas)],
+                    label='_nolegend_')
+        if label is not None:
+            has_label = True
+    if has_label:
+        fig.legend(loc="upper right", labelspacing=0.1, fontsize='small')
+    return plt
+
+
+def radar_factory(num_vars):
+    """
+    Create a radar chart with `num_vars` Axes.
+
+    This function creates a RadarAxes projection and registers it.
+
+    Based on
+    https://matplotlib.org/stable/gallery/specialty_plots/radar_chart.html
+
+    Parameters
+    ----------
+    num_vars : int
+        Number of variables for radar chart.
+    """
+    # calculate evenly-spaced axis angles
+    theta = np.linspace(2 * np.pi, 0, num_vars, endpoint=False)
+
+    class RadarTransform(PolarAxes.PolarTransform):
+
+        def transform_path_non_affine(self, path):
+            # Paths with non-unit interpolation steps correspond to gridlines,
+            # in which case we force interpolation (to defeat PolarTransform's
+            # autoconversion to circular arcs).
+            if path._interpolation_steps > 1:
+                path = path.interpolated(num_vars)
+            return Path(self.transform(path.vertices), path.codes)
+
+    class RadarAxes(PolarAxes):
+
+        name = 'radar'
+        PolarTransform = RadarTransform
+
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+            # rotate plot such that the first axis is at the top
+            self.set_theta_zero_location('N')
+
+        def fill(self, *args, closed=True, **kwargs):
+            """Override fill so that line is closed by default"""
+            return super().fill(closed=closed, *args, **kwargs)
+
+        def plot(self, *args, **kwargs) -> list[Line2D]:
+            """Override plot so that line is closed by default"""
+            lines = super().plot(*args, **kwargs)
+            for line in lines:
+                self._close_line(line)
+            return lines
+
+        def _close_line(self, line):
+            x, y = line.get_data()
+            # FIXME: markers at x[0], y[0] get doubled-up
+            if x[0] != x[-1]:
+                x = np.append(x, x[0])
+                y = np.append(y, y[0])
+                line.set_data(x, y)
+
+        def set_varlabels(self, labels):
+            self.set_thetagrids(np.degrees(theta), fmt="")
+            for i in range(len(labels)):
+                horizontal_alignment = None
+                if i == 0 or i == len(labels) / 2:
+                    horizontal_alignment = "center"
+                elif i < len(labels) / 2:
+                    horizontal_alignment = "left"
+                else:
+                    horizontal_alignment = "right"
+
+                vertical_alignment = None
+                if i == len(labels) / 4 or i == (len(labels) * 3 / 4):
+                    vertical_alignment = "center"
+                elif i < len(labels) / 4 or i > (len(labels) * 3 / 4):
+                    vertical_alignment = "bottom"
+                else:
+                    vertical_alignment = "top"
+
+                self.text(theta[i], 1.025, labels[i], fontsize="small",
+                          horizontalalignment=horizontal_alignment,
+                          verticalalignment=vertical_alignment)
+
+        def _gen_axes_patch(self):
+            # The Axes patch must be centered at (0.5, 0.5) and of radius 0.5
+            # in axes coordinates.
+            return RegularPolygon((0.5, 0.5), num_vars,
+                                  radius=.5, edgecolor="k")
+
+        def _gen_axes_spines(self):
+            # spine_type must be 'left'/'right'/'top'/'bottom'/'circle'.
+            spine = Spine(axes=self,
+                          spine_type='circle',
+                          path=Path.unit_regular_polygon(num_vars))
+            # unit_regular_polygon gives a polygon of radius 1 centered at
+            # (0, 0) but we want a polygon of radius 0.5 centered at (0.5,
+            # 0.5) in axes coordinates.
+            spine.set_transform(Affine2D().scale(.5).translate(.5, .5) + self.transAxes)
+            return {'polar': spine}
+
+    register_projection(RadarAxes)
+    return theta