aletk 0.1.4__tar.gz → 0.1.6__tar.gz

aletk-0.1.6/.gitignore

@@ -0,0 +1,171 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# PyPI configuration file
+.pypirc

aletk-0.1.6/.gitlab-ci.yml

@@ -0,0 +1,55 @@
+stages:
+  - build
+  - publish
+  - release
+
+workflow:
+  rules:
+    - if: $CI_COMMIT_TAG && $CI_COMMIT_TAG =~ /^v[0-9]+\.[0-9]+\.[0-9]+$/
+
+build:
+  stage: build
+  image: python:3-bookworm
+  script:
+    - python -m pip install -U build
+    - python -m build
+  artifacts:
+    paths:
+      - "dist/"
+
+publish:
+  stage: publish
+  image: python:3-bookworm
+  dependencies:
+    - build
+  environment:
+    name: release
+  id_tokens:
+    PYPI_ID_TOKEN:
+      # Use "testpypi" if uploading to TestPyPI
+      aud: pypi
+  script:
+    # Install dependencies
+    - apt update && apt install -y jq
+    - python -m pip install -U twine id
+
+    # Retrieve the OIDC token from GitLab CI/CD, and exchange it for a PyPI API token
+    - oidc_token=$(python -m id PYPI)
+    # Replace "https://pypi.org/*" with "https://test.pypi.org/*" if uploading to TestPyPI
+    - resp=$(curl -X POST https://pypi.org/_/oidc/mint-token -d "{\"token\":\"${oidc_token}\"}")
+    - api_token=$(jq --raw-output '.token' <<< "${resp}")
+
+    # Upload to PyPI authenticating via the newly-minted token
+    # Add "--repository testpypi" if uploading to TestPyPI
+    - twine upload -u __token__ -p "${api_token}" dist/*
+
+release:
+  stage: release
+  image: registry.gitlab.com/gitlab-org/release-cli:latest
+  dependencies:
+    - publish
+  script:
+    - echo "Running release-cli"
+  release:
+    tag_name: '$CI_COMMIT_TAG'
+    description: 'Release $CI_COMMIT_TAG'

aletk-0.1.6/.python-version

@@ -0,0 +1 @@
+3.13

{aletk-0.1.4 → aletk-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: aletk
-Version: 0.1.4
+Version: 0.1.6
 Summary: Collection of general purpose tools to work with Python
 Author-email: Luis Alejandro Bordo García <bgluiszz@gmail.com>
 License: MIT

aletk-0.1.6/prototypes/MaybeMonad.py

@@ -0,0 +1,131 @@
+from dataclasses import dataclass
+from typing import Callable
+
+
+@dataclass(slots=True, frozen=True)
+class Some[T]:
+    """
+    Model for the success case of a function in this project.
+
+    Attributes
+    ----------
+    value : T
+        The data returned by the function.
+    """
+
+    value: T
+
+
+@dataclass(slots=True, frozen=True)
+class Nothing:
+    """
+    Model for the error case of a function in this project.
+
+    Attributes
+    ----------
+    message : str
+        A message describing the error.
+    code : int
+        A code that can be used to handle different error cases.
+    """
+
+    pass
+
+
+type Maybe[T] = Some[T] | Nothing
+
+
+def mmap[T, U](f: Callable[[T], U], maybe: Some[T] | Nothing) -> Some[U] | Nothing:
+    """
+    Map a function over a Maybe.
+
+    Parameters
+    ----------
+    f : Callable[[T], U]
+        The function to map over the Maybe.
+    maybe : Maybe[T]
+        The Maybe to map the function over.
+
+    Returns
+    -------
+    Maybe[U]
+    """
+    match maybe:
+        case Some(value=value):
+            return Some(value=f(value))
+        case Nothing():
+            return maybe
+        case _:
+            raise ValueError("Invalid Maybe type.")
+
+
+def mbind[T, U](f: Callable[[T], Some[U] | Nothing], maybe: Some[T] | Nothing) -> Some[U] | Nothing:
+    """
+    Bind a function over a Maybe.
+
+    Parameters
+    ----------
+    f : Callable[[T], Some[U] | Nothing]
+        The function to bind over the Maybe.
+    maybe : Maybe[T]
+        The Maybe to bind the function over.
+
+    Returns
+    -------
+    Maybe[U]
+    """
+    match maybe:
+        case Some(value):
+            return f(value)
+        case Nothing():
+            return maybe
+        case _:
+            raise ValueError("Invalid Maybe type.")
+
+
+def munwrap[T](maybe: Some[T] | Nothing) -> T:
+    """
+    Unwrap a Maybe.
+
+    Parameters
+    ----------
+    maybe : Maybe[T]
+        The Maybe to unwrap.
+
+    Returns
+    -------
+    T
+        The value of the Maybe.
+    """
+    match maybe:
+        case Some(value):
+            return value
+        case Nothing():
+            raise ValueError("Cannot unwrap a Nothing.")
+        case _:
+            raise ValueError("Invalid Maybe type.")
+
+
+def munwrap_or[T](maybe: Some[T] | Nothing, default: T) -> T:
+    """
+    Unwrap a Maybe or return a default value.
+
+    Parameters
+    ----------
+    maybe : Maybe[T]
+        The Maybe to unwrap.
+    default : T
+        The default value to return if the Maybe is a Nothing.
+
+    Returns
+    -------
+    T
+        The value of the Maybe or the default value.
+    """
+    match maybe:
+        case Some(value):
+            return value
+        case Nothing():
+            return default
+        case _:
+            raise ValueError("Invalid Maybe type.")

aletk-0.1.6/prototypes/pipe.ipynb

@@ -0,0 +1,211 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pipe import pipe, pipe_out"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "res = pipe(1) >> (lambda x: x + 1) >> (lambda x: x * 2) >> pipe_out"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "int"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "res.__class__"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "res = (pipe(3)\n",
+    "       >> (lambda x: x + 1)\n",
+    "       >> (lambda x: x * 2)\n",
+    "       >> pipe_out\n",
+    "    )\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "int"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "res.__class__"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from aletk.ResultMonad import try_except_wrapper, funwrap\n",
+    "from aletk.utils import get_logger\n",
+    "\n",
+    "lgr = get_logger(\"pipe test\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "g_error_msg = \"g error\"\n",
+    "h_error_msg = \"h error\"\n",
+    "\n",
+    "@try_except_wrapper(lgr)\n",
+    "def f(x):\n",
+    "    return x + 1\n",
+    "\n",
+    "@try_except_wrapper(lgr)\n",
+    "def g(x):\n",
+    "    raise ValueError(g_error_msg)\n",
+    "\n",
+    "@try_except_wrapper(lgr)\n",
+    "def h(x):\n",
+    "    raise ValueError(h_error_msg)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "3"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pipe(1) >> funwrap(f) >> funwrap(f) >> pipe_out"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2024-12-29 01:34:35 - pipe test - ERROR - An error occurred in function 'g'. Detail:\n",
+      "g error\n",
+      "2024-12-29 01:34:35 - pipe test - ERROR - An error occurred in function 'f'. Detail:\n",
+      "unsupported operand type(s) for +: 'Err' and 'int'\n"
+     ]
+    }
+   ],
+   "source": [
+    "res = pipe(1) >> f >> g >> f >> pipe_out"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Err(message=\"An error occurred in function 'f'. Detail: unsupported operand type(s) for +: 'Err' and 'int'\", code=-1)"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "res"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "AssertionError",
+     "evalue": "TODO: should return the error thrown by 'g' ('g error'), as it is the first error in the chain and errors should propagate. Failed with:\n\t \"g error\" != \"An error occurred in function 'f'. Detail: unsupported operand type(s) for +: 'Err' and 'int'\"",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[12], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m res\u001b[38;5;241m.\u001b[39mmessage \u001b[38;5;241m==\u001b[39m g_error_msg, \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mTODO: should return the error thrown by \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mg\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m (\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mg_error_msg\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m), as it is the first error in the chain and errors should propagate. Failed with:\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;130;01m\\t\u001b[39;00m\u001b[38;5;124m \u001b[39m\u001b[38;5;130;01m\\\"\u001b[39;00m\u001b[38;5;132;01m{\u001b[39;00mg_error_msg\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;130;01m\\\"\u001b[39;00m\u001b[38;5;124m != \u001b[39m\u001b[38;5;130;01m\\\"\u001b[39;00m\u001b[38;5;132;01m{\u001b[39;00mres\u001b[38;5;241m.\u001b[39mmessage\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;130;01m\\\"\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n",
+      "\u001b[0;31mAssertionError\u001b[0m: TODO: should return the error thrown by 'g' ('g error'), as it is the first error in the chain and errors should propagate. Failed with:\n\t \"g error\" != \"An error occurred in function 'f'. Detail: unsupported operand type(s) for +: 'Err' and 'int'\""
+     ]
+    }
+   ],
+   "source": [
+    "assert res.message == g_error_msg, f\"TODO: should return the error thrown by 'g' ('{g_error_msg}'), as it is the first error in the chain and errors should propagate. Failed with:\\n\\t \\\"{g_error_msg}\\\" != \\\"{res.message}\\\"\"\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "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.13.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

aletk-0.1.6/prototypes/pipe.py

@@ -0,0 +1,85 @@
+### TO DELETE IF THIS EVER GETS IMPLEMENTED IN THE MAIN LIBRARY ###
+import sys
+
+sys.path.append('..')
+### ###
+
+from typing import Callable
+
+from src.aletk.ResultMonad import Err, Ok
+
+
+class pipe[T]:
+    """
+    A pipe object that can be used to chain functions together with the `>>` operator.
+
+    ### Example
+
+    ```python
+    from aletk import pipe
+
+    def add_one(x: int) -> int:
+        return x + 1
+
+    def multiply_by_two(x: int) -> int:
+        return x * 2
+
+    result = pipe(1) >> add_one >> multiply_by_two
+    print(result.output)  # 4
+    ``
+    """
+
+    def __init__(self, value: T):
+        self.value = value
+
+    @property
+    def output(self) -> T:
+        return self.value
+
+    def __rshift__[
+        U
+    ](self, func: Callable[[T | 'pipe[T]'], U | Ok[U]]) -> 'pipe[U]' | U | 'pipe[T]' | Err | 'pipe[Err]' | Ok[U]:
+        if func is pipe_out:
+            # If the function is `pipe_out`, call it directly on `self`
+            return func(self)
+
+        if isinstance(self.value, Err):
+            # Propagate Err without calling the function
+            return self
+
+        if isinstance(self.value, Ok):
+            # Unwrap the Ok value
+            unwrapped_value = self.value.out
+        else:
+            # Regular value
+            unwrapped_value = self.value
+
+        # Call the function
+        result = func(unwrapped_value)
+
+        if isinstance(result, Err):
+            # Propagate Err if returned by the function
+            return pipe(result)
+        elif isinstance(result, Ok):
+            # Wrap Ok result in pipe
+            return pipe(result)  # type: ignore
+        else:
+            # Wrap regular result in pipe
+            return pipe(result)
+
+    def __or__[U](self, func: Callable[[T | 'pipe[T]'], U]) -> 'pipe[U]' | U:
+        if func is pipe_out:
+            return func(self)
+        return pipe(func(self.value))
+
+    def __repr__(self) -> str:
+        return f'{self.value}'
+
+
+def pipe_out[T](pipe_result: pipe[T] | pipe[Ok[T]] | T) -> T:
+    if isinstance(pipe_result, pipe):
+        if isinstance(pipe_result.output, Ok):
+            return pipe_result.output.out
+
+        return pipe_result.output  # Return the unwrapped result
+    return pipe_result

{aletk-0.1.4 → aletk-0.1.6}/pyproject.toml

@@ -1,11 +1,10 @@
 [build-system]
-requires = ["setuptools>=75.6.0", "wheel"]
+requires = ["setuptools>=75.6.0", "setuptools_scm>=8.1", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "aletk"
 description = "Collection of general purpose tools to work with Python"
-version = "0.1.4"
 requires-python = ">=3.13"
 authors = [
     {name = "Luis Alejandro Bordo García", email = "bgluiszz@gmail.com"},
@@ -24,6 +23,12 @@ dependencies = [
     "fuzzywuzzy",
     "python-Levenshtein"
 ]
+dynamic = ["version"]
+
+[tool.setuptools_scm]
+version_scheme = "guess-next-dev"
+local_scheme = "no-local-version"
+write_to = "src/aletk/_version.py"
 
 [project.urls]
 Repository = "https://gitlab.com/alebg/aletk"

{aletk-0.1.4 → aletk-0.1.6}/src/aletk/ResultMonad.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 from logging import Logger
-from typing import Any, Callable, NamedTuple
+from typing import Any, Callable
 from functools import wraps
 
 
@@ -29,10 +29,16 @@ class Err:
         A message describing the error.
     code : int
         A code that can be used to handle different error cases.
+    error_type : str, optional
+        A string describing the type of error that occurred.
+    error_trace : str, optional
+        A string describing the trace of the error that occurred.
     """
 
     message: str
     code: int
+    error_type: str | None = None
+    error_trace: str | None = None
 
 
 type TResult[T] = Ok[T] | Err

aletk-0.1.6/src/aletk/_version.py

@@ -0,0 +1,21 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.1.6'
+__version_tuple__ = version_tuple = (0, 1, 6)

{aletk-0.1.4 → aletk-0.1.6}/src/aletk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: aletk
-Version: 0.1.4
+Version: 0.1.6
 Summary: Collection of general purpose tools to work with Python
 Author-email: Luis Alejandro Bordo García <bgluiszz@gmail.com>
 License: MIT

{aletk-0.1.4 → aletk-0.1.6}/src/aletk.egg-info/SOURCES.txt

@@ -1,8 +1,15 @@
+.gitignore
+.gitlab-ci.yml
+.python-version
 LICENSE
 README.md
 pyproject.toml
+prototypes/MaybeMonad.py
+prototypes/pipe.ipynb
+prototypes/pipe.py
 src/aletk/ResultMonad.py
 src/aletk/__init__.py
+src/aletk/_version.py
 src/aletk/adapters.py
 src/aletk/py.typed
 src/aletk/utils.py
@@ -10,4 +17,5 @@ src/aletk.egg-info/PKG-INFO
 src/aletk.egg-info/SOURCES.txt
 src/aletk.egg-info/dependency_links.txt
 src/aletk.egg-info/requires.txt
-src/aletk.egg-info/top_level.txt
+src/aletk.egg-info/top_level.txt
+tests/.gitkeep