isik 0.1.0__tar.gz

isik-0.1.0/.gitattributes

@@ -0,0 +1 @@
+* text=auto eol=lf

isik-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,47 @@
+name: Publish
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.12'
+
+      - name: Install build tools
+        run: |
+          python -m pip install --upgrade pip setuptools wheel build
+
+      - name: Check if version changed
+        id: check_version
+        run: |
+          LOCAL_VERSION=$(python -c "import tomllib; print(tomllib.load(open('pyproject.toml', 'rb'))['project']['version'])")
+          PUBLISHED_VERSION=$(curl -s -f https://pypi.org/pypi/isik/json | python -c "import json, sys; print(json.load(sys.stdin).get('info', {}).get('version', ''))" || echo "")
+          echo "Local version: $LOCAL_VERSION, published version: $PUBLISHED_VERSION"
+          if [ "$LOCAL_VERSION" = "$PUBLISHED_VERSION" ]; then
+            echo "should_publish=false" >> "$GITHUB_OUTPUT"
+          else
+            echo "should_publish=true" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Build package
+        if: steps.check_version.outputs.should_publish == 'true'
+        run: |
+          python -m build
+
+      - name: Publish to PyPI
+        if: steps.check_version.outputs.should_publish == 'true'
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist

isik-0.1.0/.github/workflows/tests.yml

@@ -0,0 +1,58 @@
+name: Tests
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ['3.11', '3.12', '3.13', '3.14']
+        os-version: [ubuntu-22.04]
+
+    runs-on: ${{ matrix.os-version }}
+
+    services:
+      postgres:
+        image: postgres:16
+        env:
+          POSTGRES_USER: postgres
+          POSTGRES_PASSWORD: postgres
+          POSTGRES_DB: isik_test
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+
+    env:
+      POSTGRES_HOST: localhost
+      POSTGRES_PORT: 5432
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: isik_test
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          uv sync --all-extras
+
+      - name: Run tests with coverage
+        run: |
+          uv run coverage run -m pytest
+          uv run coverage report -m

isik-0.1.0/.gitignore

@@ -0,0 +1,18 @@
+# Python
+__pycache__
+*.pyc
+.pytest_cache
+.ruff_cache
+.coverage
+htmlcov
+.hypothesis
+
+# IDEs & Editors
+.idea
+
+# Frameworks & Libraries
+dist
+poetry.lock
+
+# Project Specific
+# ETC

isik-0.1.0/.pre-commit-config.yaml

@@ -0,0 +1,15 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: end-of-file-fixer
+      - id: trailing-whitespace
+      - id: check-yaml
+      - id: check-added-large-files
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.9.0
+    hooks:
+      - id: ruff
+        args: [ --fix ]
+      - id: ruff-format

isik-0.1.0/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Işık Kaplan
+
+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.

isik-0.1.0/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: isik
+Version: 0.1.0
+Summary: Everyday python utilities.
+Project-URL: Homepage, https://github.com/isik-kaplan/isik
+Project-URL: Repository, https://github.com/isik-kaplan/isik
+Project-URL: Documentation, https://github.com/isik-kaplan/isik
+Author-email: Işık Kaplan <isik.kaplan@outlook.com>
+License: MIT
+License-File: LICENCE
+Keywords: utility
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development
+Requires-Python: >=3.11
+Provides-Extra: all
+Requires-Dist: dalf; extra == 'all'
+Requires-Dist: django; extra == 'all'
+Requires-Dist: django-lifecycle; extra == 'all'
+Requires-Dist: django-object-actions; extra == 'all'
+Requires-Dist: django-pghistory; extra == 'all'
+Requires-Dist: djangorestframework; extra == 'all'
+Requires-Dist: mjml-python; extra == 'all'
+Requires-Dist: sentry-sdk; extra == 'all'
+Requires-Dist: whitenoise; extra == 'all'
+Provides-Extra: django
+Requires-Dist: dalf; extra == 'django'
+Requires-Dist: django; extra == 'django'
+Requires-Dist: django-lifecycle; extra == 'django'
+Requires-Dist: django-object-actions; extra == 'django'
+Requires-Dist: django-pghistory; extra == 'django'
+Requires-Dist: mjml-python; extra == 'django'
+Requires-Dist: whitenoise; extra == 'django'
+Provides-Extra: drf
+Requires-Dist: djangorestframework; extra == 'drf'
+Provides-Extra: sentry
+Requires-Dist: sentry-sdk; extra == 'sentry'
+Description-Content-Type: text/markdown
+
+Stuff I use daily 

isik-0.1.0/README.md

@@ -0,0 +1 @@
+docs/INDEX.md

isik-0.1.0/docs/INDEX.md

@@ -0,0 +1 @@
+Stuff I use daily 

isik-0.1.0/isik/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

isik-0.1.0/isik/_internal/__init__.py

@@ -0,0 +1,11 @@
+import importlib
+
+
+def check_extra(extra_name, package_name):
+    try:
+        importlib.import_module(package_name)
+    except ImportError as exception:
+        raise ImportError(
+            f"The module you are trying to use requires '{extra_name}'. "
+            f"Please install it with: pip install isik[{extra_name}]"
+        ) from exception

isik-0.1.0/isik/common/config/__init__.py

@@ -0,0 +1,25 @@
+from isik.common.config.builder import Config, config
+from isik.common.config.casters import (
+    boolean,
+    caster,
+    comma_separated_float_list,
+    comma_separated_int_list,
+    comma_separated_list,
+    integer,
+    string,
+)
+from isik.common.config.exceptions import ConfigError
+
+
+__all__ = [
+    "Config",
+    "ConfigError",
+    "boolean",
+    "caster",
+    "comma_separated_float_list",
+    "comma_separated_int_list",
+    "comma_separated_list",
+    "config",
+    "integer",
+    "string",
+]

isik-0.1.0/isik/common/config/builder.py

@@ -0,0 +1,105 @@
+import os
+
+from isik.common.config.exceptions import ConfigError
+
+
+_MISSING = object()
+
+
+class Config(dict):
+    """
+    A dict that also allows attribute access, e.g. config.DATABASE.HOST, and can reload its
+    values from the environment via refresh() - callable on the root config or on any nested
+    one, refreshing just that subtree in place so existing references to it see the update too.
+
+    A schema key that collides with a dict method name (items, keys, ...) or with refresh
+    itself is only reachable via item access (config["refresh"]), not attribute access.
+    """
+
+    __setattr__ = dict.__setitem__
+
+    def __getattr__(self, name):
+        try:
+            return self[name]
+        except KeyError as exc:
+            raise AttributeError(name) from exc
+
+    def refresh(self, *path):
+        """
+        Re-read values from the environment, in place. With no arguments, refreshes every
+        value under this node. With a path of key names, refreshes only that one nested
+        value instead - e.g. config.refresh("DATABASE", "HOST") or, equivalently,
+        config.DATABASE.refresh("HOST").
+        """
+        if not path:
+            for key in self._schema:
+                self._refresh_key(key)
+            return self
+
+        key, *rest = path
+        if rest:
+            self[key].refresh(*rest)
+        else:
+            self._refresh_key(key)
+        return self
+
+    def _refresh_key(self, key):
+        try:
+            value = self._schema[key]
+        except KeyError:
+            raise ConfigError(f"'{key}' is not a key in this config.") from None
+        if isinstance(value, dict):
+            self[key].refresh()
+        else:
+            self[key] = _read_leaf(value, _environment_key(self._prefix, [*self._path, key], self._sep))
+
+
+def _environment_key(prefix, path, sep):
+    return sep.join([*([prefix] if prefix else []), *path])
+
+
+def _read_leaf(caster, environment_key):
+    try:
+        raw_value = os.environ[environment_key]
+    except KeyError:
+        default = getattr(caster, "missing_default", _MISSING)
+        if default is _MISSING:
+            raise ConfigError(
+                f"Environment variable {environment_key} not found."
+                f" Please set it or provide a `missing_default` to your caster."
+            ) from None
+        return default
+
+    try:
+        return caster(raw_value)
+    except Exception as exception:
+        default = getattr(caster, "error_default", _MISSING)
+        if default is _MISSING:
+            raise ConfigError(
+                f"Error while parsing {environment_key}={raw_value!r} with '{caster}'."
+                " Please check the value and the caster or provide an `error_default` to your caster."
+            ) from exception
+        return default
+
+
+def _build(data, path, prefix, sep):
+    result = Config()
+    object.__setattr__(result, "_schema", data)
+    object.__setattr__(result, "_path", path)
+    object.__setattr__(result, "_prefix", prefix)
+    object.__setattr__(result, "_sep", sep)
+    for key, value in data.items():
+        key_path = [*path, key]
+        if isinstance(value, dict):
+            result[key] = _build(value, key_path, prefix, sep)
+        elif callable(value):
+            result[key] = _read_leaf(value, _environment_key(prefix, key_path, sep))
+        else:
+            raise ConfigError(
+                f"Values either must be callables or other mappings, not {type(value)}. Key={'.'.join(key_path)}."
+            )
+    return result
+
+
+def config(data, *, prefix=None, sep="__"):
+    return _build(data, [], prefix, sep)

isik-0.1.0/isik/common/config/casters.py

@@ -0,0 +1,56 @@
+from functools import wraps
+
+
+def caster(f):
+    """
+    Turns a plain string->value function into a config caster that accepts an optional
+    missing_default (used when the environment variable isn't set) and error_default (used
+    when f(value) raises). Neither is set by default, meaning a missing or unparseable
+    value raises ConfigError instead.
+    """
+    sentinel = object()
+
+    def wrapper(missing_default=sentinel, error_default=sentinel):
+        @wraps(f)
+        def function_clone(value):
+            return f(value)
+
+        if missing_default is not sentinel:
+            function_clone.missing_default = missing_default
+        if error_default is not sentinel:
+            function_clone.error_default = error_default
+        return function_clone
+
+    return wrapper
+
+
+@caster
+def comma_separated_list(value):
+    return value.split(",")
+
+
+@caster
+def comma_separated_int_list(value):
+    return [int(i) for i in value.split(",")]
+
+
+@caster
+def comma_separated_float_list(value):
+    return [float(i) for i in value.split(",")]
+
+
+@caster
+def boolean(value):
+    truthy = ["true", "True", "1"]
+    falsy = ["false", "False", "0"]
+
+    if value in truthy:
+        return True
+    elif value in falsy:
+        return False
+    else:
+        raise ValueError(f"Value {value!r} can not be parsed into a boolean.")
+
+
+string = caster(str)
+integer = caster(int)

isik-0.1.0/isik/common/config/exceptions.py

@@ -0,0 +1 @@
+class ConfigError(ValueError): ...

isik-0.1.0/isik/common/utils/__init__.py

@@ -0,0 +1,46 @@
+from isik.common.utils.caching import get_cached
+from isik.common.utils.concurrency import ContextLocal, ThreadLocal, ThreadLock
+from isik.common.utils.error_handling import SuppressAndRun, TransformExceptions, suppress_callable
+from isik.common.utils.functional import (
+    cloned,
+    enabled_if,
+    identity,
+    noop,
+    raises,
+    require_exclusive_keys,
+    returns,
+    with_attrs,
+)
+from isik.common.utils.iterables import all_combinations, first_of, not_none, purge_iterable, purge_mapping
+from isik.common.utils.metaclasses import transform
+from isik.common.utils.sentinel import Sentinel
+from isik.common.utils.strings import camel_to_snake, snake_to_human, snake_to_pascal
+
+
+__all__ = [
+    "ContextLocal",
+    "Sentinel",
+    "SuppressAndRun",
+    "ThreadLocal",
+    "ThreadLock",
+    "TransformExceptions",
+    "all_combinations",
+    "camel_to_snake",
+    "cloned",
+    "enabled_if",
+    "first_of",
+    "get_cached",
+    "identity",
+    "noop",
+    "not_none",
+    "purge_iterable",
+    "purge_mapping",
+    "raises",
+    "require_exclusive_keys",
+    "returns",
+    "snake_to_human",
+    "snake_to_pascal",
+    "suppress_callable",
+    "transform",
+    "with_attrs",
+]

isik-0.1.0/isik/common/utils/caching.py

@@ -0,0 +1,21 @@
+def get_cached(obj, attr, factory):
+    """
+    Get a cached attribute from an object, computing and storing it if absent.
+
+    Bypasses __getattribute__ via object.__getattribute__ and object.__setattr__,
+    making it safe to call from within a custom __getattribute__ implementation.
+
+    Args:
+        obj: The object to cache the attribute on.
+        attr: The attribute name to use as the cache key.
+        factory: A zero-argument callable that computes the value on cache miss.
+
+    Returns:
+        The cached value if present, otherwise the result of calling factory().
+    """
+    try:
+        return object.__getattribute__(obj, attr)
+    except AttributeError:
+        value = factory()
+        object.__setattr__(obj, attr, value)
+        return value

isik-0.1.0/isik/common/utils/concurrency.py

@@ -0,0 +1,83 @@
+import threading
+from contextvars import ContextVar
+
+
+class ThreadLocal:
+    """
+    A factory for thread local identified by name.
+    Calling ThreadLocal("FOO") returns a thread local object shared across all calls with the same name.
+    """
+
+    _registry = {}
+    _registry_lock = threading.Lock()
+
+    def __new__(cls, name):
+        if name not in cls._registry:
+            with cls._registry_lock:
+                if name not in cls._registry:
+                    cls._registry[name] = threading.local()
+        return cls._registry[name]
+
+
+class ThreadLock:
+    """
+    A factory for thread lock identified by name.
+    Calling ThreadLock("FOO") returns a lock object shared across all calls with the same name.
+    """
+
+    _registry = {}
+    _registry_lock = threading.Lock()
+
+    def __new__(cls, name):
+        if name not in cls._registry:
+            with cls._registry_lock:
+                if name not in cls._registry:
+                    cls._registry[name] = threading.Lock()
+        return cls._registry[name]
+
+
+class ContextLocal:
+    """
+    A named, registry-backed namespace of ContextVars.
+    Calling ContextLocal("FOO") returns the same instance across all calls with the same name,
+    making it safe for async and coroutine contexts.
+
+    Usage:
+        local = ContextLocal("MY_NAMESPACE")
+        token = local.set("foo", "bar")
+        local.get("foo")  # "bar"
+        local.get("foo", "default")  # "bar"
+        local.reset("foo", token)
+    """
+
+    _registry = {}
+    _registry_lock = threading.Lock()
+
+    def __new__(cls, name):
+        if name not in cls._registry:
+            with cls._registry_lock:
+                if name not in cls._registry:
+                    instance = super().__new__(cls)
+                    object.__setattr__(instance, "_name", name)
+                    object.__setattr__(instance, "_vars", {})
+                    cls._registry[name] = instance
+        return cls._registry[name]
+
+    def _get_var(self, key):
+        vars_ = object.__getattribute__(self, "_vars")
+        if key not in vars_:
+            name = object.__getattribute__(self, "_name")
+            vars_[key] = ContextVar(f"{name}.{key}")
+        return vars_[key]
+
+    def get(self, key, *args):
+        """Get a value. Accepts an optional default as a second argument, like dict.get()."""
+        return self._get_var(key).get(*args)
+
+    def set(self, key, value):
+        """Set a value and return a token that can be used to restore the previous state."""
+        return self._get_var(key).set(value)
+
+    def reset(self, key, token):
+        """Reset a value to its state before the corresponding set() call."""
+        self._get_var(key).reset(token)