Basic project and docs

Author: davidhozic

.gitignore

@@ -158,3 +158,7 @@ cython_debug/
 #  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/
+
+
+
+**test.py**

README.rst

@@ -0,0 +1,29 @@
+=================
+TkClassWizard
+=================
+
+Library for graphically defining objects based on class annotations.
+Works with Tkinter / TTKBootstrap
+
+Example
+============
+
+.. code-block:: python
+
+    import tkclasswiz as wiz
+
+
+    class Wheel:
+        def __init__(self, diameter: float):
+            self.diameter = diameter
+
+    class Car:
+        def __init__(self, name: str, speed: float, wheels: list[Wheel]):
+            self.name = name
+            self.speed = speed
+            self.wheels = wheels
+
+
+    combo = wiz.ComboBoxObjects()
+    window = ObjectEditWindow()
+    window.open_object_edit_frame(Car, combo)

pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = [
+    "wheel",
+]
+
+build-backend = "setuptools.build_meta"
+
+
+[project]
+name = "TkClassWiz"
+authors = [
+    {name = "David Hozic"}
+]
+description = "Library for graphically defining objects based on class annotations. Works with Tkinter / TTKBootstrap"
+readme = "README.rst"
+requires-python = ">=3.8"
+keywords = ["Tkinter", "TTKBootstrap", "Python3", "ObjectDef", "ClassWiz", "ClassWiz", "GUI"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+dynamic = ["optional-dependencies", "version"]
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.dynamic]
+version = {attr = "tkclasswiz.__version__"}
+
+[tool.setuptools.dynamic.optional-dependencies]
+docs = {file = "requirements/docs.txt"}
+
+tool.setuptools.packages = [
+    "tkclasswiz"
+]

requirements/docs.txt

@@ -0,0 +1,15 @@
+"""
+TkClassWizard - Library for graphically defining objects based on class annotations.
+Works with Tkinter / TTKBootstrap.
+"""
+
+__version__ = "1.0.0"
+
+from .object_frame import *
+from .annotations import *
+from .cache import *
+from .convert import *
+from .extensions import *
+from .messagebox import *
+from .storage import *
+from .utilities import *

tkclasswiz/__init__.py

@@ -0,0 +1,102 @@
+"""
+Module used for managing annotations.
+"""
+from datetime import datetime, timedelta, timezone
+from typing import Union, Optional
+from contextlib import suppress
+from inspect import isclass
+
+
+__all__ = (
+    "register_annotations",
+    "get_annotations",
+)
+
+
+ADDITIONAL_ANNOTATIONS = {
+    timedelta: {
+        "days": float,
+        "seconds": float,
+        "microseconds": float,
+        "milliseconds": float,
+        "minutes": float,
+        "hours": float,
+        "weeks": float
+    },
+    datetime: {
+        "year": int,
+        "month": Union[int, None],
+        "day": Union[int, None],
+        "hour": int,
+        "minute": int,
+        "second": int,
+        "microsecond": int,
+        "tzinfo": timezone
+    },
+    timezone: {
+        "offset": timedelta,
+        "name": str
+    },
+}
+
+
+def register_annotations(cls: type, mapping: Optional[dict] = {}, **annotations):
+    """
+    Extends original annotations of ``cls``.
+
+    This can be useful eg. when the class your
+    are adding is not part of your code and is also not annotated.
+
+    Classes that already have additional annotations:
+
+    - datetime.timedelta
+    - datetime.datetime 
+    - datetime.timezone
+
+    Parameters
+    ------------
+    cls: type
+        The class (or function) to register additional annotations on.
+    mapping: Optional[Dict[str, type]]
+        Mapping mapping the parameter name to it's type.
+    annotations: Optional[Unpack[str, type]]
+        Keyword arguments mapping parameter name to it's type (``name=type``).
+
+    Example
+    -----------
+    
+    .. code-block:: python
+
+        from datetime import timedelta, timezone
+
+        register_annotations(
+            timezone,
+            offset=timedelta,
+            name=str
+        )    
+    """
+    if cls not in ADDITIONAL_ANNOTATIONS:
+        ADDITIONAL_ANNOTATIONS[cls] = {}
+
+    ADDITIONAL_ANNOTATIONS[cls].update(**annotations, **mapping)
+
+
+def get_annotations(class_) -> dict:
+    """
+    Returns class / function annotations including the ones extended with ``register_annotations``.
+    It does not return the return annotation.
+    """
+    annotations = {}
+    with suppress(AttributeError):
+        if isclass(class_):
+            annotations = class_.__init__.__annotations__
+        else:
+            annotations = class_.__annotations__
+
+    additional_annotations = ADDITIONAL_ANNOTATIONS.get(class_, {})
+    annotations = {**annotations, **additional_annotations}
+
+    if "return" in annotations:
+        del annotations["return"]
+
+    return annotations

tkclasswiz/annotations.py

@@ -0,0 +1,51 @@
+"""
+Utility module used for caching.
+"""
+from typing import Callable
+from functools import wraps
+import pickle
+
+
+__all__ = (
+    "cache_result",
+)
+
+
+# Caching
+def cache_result(max: int = 256):
+    """
+    Caching function that also allows dictionary and lists to be used as a key.
+
+    Parameters
+    --------------
+    max: int
+        The maximum number of items inside the cache.
+    """
+    def _decorator(fnc: Callable):
+        cache_dict = {}
+
+        @wraps(fnc)
+        def wrapper(*args, **kwargs):
+            try:
+                # Convert to pickle string to allow hashing of non-hashables (dictionaries, lists, ...)
+                key = pickle.dumps((*args, kwargs))
+            except Exception:
+                return fnc(*args, **kwargs)
+
+            result = cache_dict.get(key, Ellipsis)
+            if result is not Ellipsis:
+                return result
+
+            result = fnc(*args, **kwargs)
+            cache_dict[key] = result
+
+            if len(cache_dict) > max:
+                items = list(cache_dict.items())[:max // 2]
+                cache_dict.clear()
+                cache_dict.update(items)
+
+            return result
+
+        return wrapper
+
+    return _decorator