v440 0.2.0__3-none-any.whl

v440/__init__.py

@@ -0,0 +1 @@
+from v440._core import *

v440/_core/Local.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import types
+import typing
+
+import scaevola
+
+from . import utils
+
+
+@utils.compclass(list)
+class Local(scaevola.Scaevola):
+    def __add__(self, other, /):
+        return self._new(self._data + self._todata(other))
+
+    @classmethod
+    def __class_getitem__(cls, key, /):
+        return types.GenericAlias(cls, key)
+
+    def __eq__(self, other):
+        if type(self) != type(other):
+            return False
+        return self._data == other._data
+
+    def __getitem__(self, key, /):
+        if type(key) is not slice:
+            return self._data[key]
+        return self._new(self._data[key])
+
+    def __hash__(self):
+        raise TypeError("unhashable type: %r" % type(self).__name__)
+
+    def __iadd__(self, other, /):
+        self._data += self._todata(other)
+
+    def __imul__(self, other, /):
+        self._data *= other
+
+    def __init__(self, data=[]):
+        self.data = data
+
+    def __le__(self, other):
+        other = type(self)(other)
+        return self._cmpkey() <= other._cmpkey()
+
+    def __lt__(self, other):
+        other = type(self)(other)
+        return self._cmpkey() < other._cmpkey()
+
+    def __mul__(self, other, /):
+        return self._new(self._data * other)
+
+    def __repr__(self) -> str:
+        return "%s(%r)" % (type(self).__name__, str(self))
+
+    def __reversed__(self, /):
+        ans = self[:]
+        ans._data.reverse()
+        return ans
+
+    def __rmul__(self, other, /):
+        return self.__mul__(other)
+
+    def __setitem__(self, key, value, /):
+        if type(key) is not slice:
+            self._data[key] = utils.segment(value)
+        else:
+            self._data[key] = self._todata(value._data)
+
+    def __str__(self) -> str:
+        return ".".join(str(x) for x in self)
+
+    def _cmpkey(self):
+        return [self._sortkey(x) for x in self]
+
+    @classmethod
+    def _new(cls, data, /):
+        ans = object.__new__(cls)
+        ans._data = data
+        return ans
+
+    @staticmethod
+    def _sortkey(value):
+        return type(value) is int, value
+
+    @staticmethod
+    def _todata(data, /):
+        return utils.todata(data, "+")
+
+    def append(self, elem, /):
+        self._data.append(utils.segment(elem))
+
+    def copy(self):
+        return self._new(self.data)
+
+    @property
+    def data(self, /):
+        return list(self._data)
+
+    @data.setter
+    @utils.setterdeco
+    def data(self, data, /):
+        self._data = self._todata(data)
+
+    @data.deleter
+    def data(self):
+        self._data = []
+
+    def extend(self, data, /):
+        self.__iadd__(data)
+
+    def insert(self, index, elem, /):
+        self._data.insert(index, utils.segment(elem))
+
+    def sort(self, *, key=None, reverse=False):
+        if key is None:
+            key = self._sortkey
+        self._data.sort(key=key, reverse=reverse)

v440/_core/Pre.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+import typing
+
+import scaevola
+
+from . import utils
+
+
+class Pre:
+    _PHASEDICT = dict(
+        alpha="a",
+        a="a",
+        beta="b",
+        b="b",
+        preview="rc",
+        pre="rc",
+        c="rc",
+        rc="rc",
+    )
+
+    def __bool__(self):
+        return bool(self.phase)
+
+    def __eq__(self, other):
+        if type(other) is not type(self):
+            return False
+        return self.data == other.data
+
+    def __hash__(self) -> int:
+        return hash((self.phase, self.subphase))
+
+    @typing.overload
+    def __init__(self, data=None) -> None: ...
+    @typing.overload
+    def __init__(self, phase, subphase=0): ...
+
+    def __init__(self, *args, **kwargs):
+        self._init(*args, **kwargs)(*args, **kwargs)
+
+    def __repr__(self) -> str:
+        return "%s(%r)" % (type(self).__name__, str(self))
+
+    def __str__(self) -> str:
+        if self:
+            return self.phase + str(self.subphase)
+        else:
+            return ""
+
+    def _init(self, *args, **kwargs):
+        if "data" in kwargs.keys():
+            return self._init_data
+        if kwargs:
+            return self._init_items
+        if len(args) > 1:
+            return self._init_items
+        return self._init_data
+
+    def _init_data(self, data=None):
+        self.data = data
+
+    def _init_items(self, phase, subphase=0):
+        self.phase = phase
+        self.subphase = subphase
+
+    def copy(self):
+        return type(self)(self)
+
+    @property
+    def data(self):
+        if not self.phase:
+            return None
+        return self.phase, self.subphase
+
+    @data.setter
+    @utils.setterdeco
+    def data(self, value, /):
+        value = utils.todata(value, ".")
+        if len(value) == 0:
+            del self.data
+            return
+        if len(value) > 1:
+            self.phase, self.subphase = value
+            return
+        value = value[0]
+        if type(value) is int:
+            raise TypeError
+        for long, short in type(self)._PHASEDICT.items():
+            p, value = utils.lsplit(value, long, "")
+            if p == "":
+                continue
+            self.phase = short
+            self.subphase = value[len(long) :]
+            return
+        raise ValueError
+
+    @data.deleter
+    def data(self):
+        del self.phase
+
+    @property
+    def phase(self):
+        return self._phase
+
+    @phase.setter
+    @utils.setterdeco
+    def phase(self, value):
+        if not value:
+            del self.phase
+            return
+        value = utils.literal(value)
+        value = type(self)._PHASEDICT[value]
+        self._phase = value
+
+    @phase.deleter
+    def phase(self):
+        self._phase = None
+        self._subphase = 0
+
+    @property
+    def subphase(self):
+        return self._subphase
+
+    @subphase.setter
+    @utils.setterdeco
+    def subphase(self, value):
+        value = utils.numeral(value)
+        if value == 0:
+            del self.subphase
+            return
+        if self.phase:
+            self._subphase = value
+            return
+        raise utils.VersionError("no subphase allowed without a phase")
+
+    @subphase.deleter
+    def subphase(self):
+        self._subphase = 0

v440/_core/Release.py

@@ -0,0 +1,251 @@
+from __future__ import annotations
+
+import types
+import typing
+
+import scaevola
+
+from . import utils
+
+
+@utils.compclass(list)
+class Release(scaevola.Scaevola):
+    def __add__(self, other):
+        return type(self)(self._data + list(other))
+
+    @classmethod
+    def __class_getitem__(cls, key, /):
+        return types.GenericAlias(cls, key)
+
+    def __delitem__(self, index, /) -> None:
+        del self._data[index]
+        self._rstrip()
+
+    def __eq__(self, other):
+        if type(self) != type(other):
+            return False
+        return self._data == other._data
+
+    def __format__(self, cutoff=None):
+        return self.format(cutoff=cutoff)
+
+    def __getitem__(self, key):
+        if type(key) is slice:
+            return self._getitem_slice(key)
+        else:
+            return self._getitem_index(key)
+
+    def __hash__(self):
+        raise TypeError("unhashable type: %r" % type(self).__name__)
+
+    def __iadd__(self, other, /):
+        self._data += self._todata(other)
+        self._rstrip()
+
+    def __init__(self, data=[], /):
+        self.data = data
+
+    def __le__(self, other):
+        other = type(self)(other)
+        return self._data <= other._data
+
+    def __lt__(self, other):
+        other = type(self)(other)
+        return self._data < other._data
+
+    def __mul__(self, other):
+        return self._new(self._data * other)
+
+    def __repr__(self) -> str:
+        return "%s(%r)" % (type(self).__name__, str(self))
+
+    def __reversed__(self):
+        return type(self)(reversed(self._data))
+
+    def __rmul__(self, other):
+        return self.__mul__(other)
+
+    def __setitem__(self, key, value):
+        if type(key) is slice:
+            self._setitem_slice(key, value)
+        else:
+            self._setitem_index(key, value)
+
+    def __str__(self) -> str:
+        return ".".join(str(x) for x in self)
+
+    def _getitem_index(self, key):
+        key = utils.toindex(key)
+        if len(self) <= key:
+            return 0
+        return self._data[key]
+
+    def _getitem_slice(self, key):
+        ans = self._range(key)
+        ans = [self._getitem_index(i) for i in ans]
+        return ans
+
+    @classmethod
+    def _new(cls, data, /):
+        ans = object.__new__(cls)
+        ans._data = data
+        return ans
+
+    def _range(self, key):
+        start = key.start
+        stop = key.stop
+        step = key.step
+        if step is None:
+            step = 1
+        else:
+            step = utils.toindex(step)
+            if step == 0:
+                raise ValueError
+        fwd = step > 0
+        if start is None:
+            start = 0 if fwd else len(self) - 1
+        else:
+            start = utils.toindex(start)
+        if stop is None:
+            stop = len(self) if fwd else -1
+        else:
+            stop = utils.toindex(stop)
+        if start < 0:
+            start += len(self)
+        if start < 0:
+            start = 0 if fwd else -1
+        if stop < 0:
+            stop += len(self)
+        if stop < 0:
+            stop = 0 if fwd else -1
+        return range(start, stop, step)
+
+    def _rstrip(self):
+        if not self._data:
+            return
+        while self._data[-1] == 0:
+            self._data.pop(0)
+
+    def _setitem_index(self, key, value):
+        key = utils.toindex(key)
+        value = utils.numeral(value)
+        if len(self) > key:
+            self._data[key] = value
+            self._rstrip()
+            return
+        if value == 0:
+            return
+        self._data.extend([0] * (key - len(self)))
+        self._data.append(value)
+
+    def _setitem_slice(self, key, value):
+        key = list(self._range(key))
+        value = self._todata(value)
+        if len(key) != len(value):
+            e = "attempt to assign sequence of size %s to extended slice of size %s"
+            e %= (len(value), len(key))
+            raise ValueError(e)
+        for k, v in zip(key, value):
+            self._setitem_index(k, v)
+
+    @staticmethod
+    def _todata(value):
+        return [utils.numeral(x) for x in utils.tolist(value, "v")]
+
+    def append(self, element):
+        element = utils.numeral(element)
+        if element:
+            self._data.append(element)
+
+    def bump(self, index=-1, amount=1):
+        x = self._getitem_index(index) + amount
+        self._setitem_index(index, x)
+        if index != -1:
+            self._data = self._data[: index + 1]
+            self._rstrip()
+
+    def copy(self):
+        return self.__mul__(1)
+
+    @property
+    def data(self):
+        return list(self._data)
+
+    @data.setter
+    @utils.setterdeco
+    def data(self, v):
+        del self.data
+        self.extend(v)
+
+    @data.deleter
+    def data(self):
+        self._data = []
+
+    def extend(self, data, /):
+        self._data.extend(self._todata(data))
+        self._rstrip()
+
+    def format(self, cutoff=None):
+        ans = self[:cutoff]
+        ans = [str(x) for x in ans]
+        ans = ".".join(ans)
+        return ans
+
+    def insert(self, index, elem, /):
+        self[index:index] = [elem]
+
+    @property
+    def major(self) -> int:
+        return self[0]
+
+    @major.setter
+    @utils.setterdeco
+    def major(self, value: typing.Any):
+        self[0] = value
+
+    @major.deleter
+    def major(self):
+        del self[0]
+
+    @property
+    def micro(self) -> int:
+        return self[2]
+
+    @micro.setter
+    @utils.setterdeco
+    def micro(self, value: typing.Any):
+        self[2] = value
+
+    @micro.deleter
+    def micro(self):
+        del self[2]
+
+    @property
+    def minor(self) -> int:
+        return self[1]
+
+    @minor.setter
+    @utils.setterdeco
+    def minor(self, value: typing.Any):
+        self[1] = value
+
+    @minor.deleter
+    def minor(self):
+        del self[1]
+
+    def pop(self, index=-1, /):
+        ans = self._data.pop(index)
+        self._rstrip()
+        return ans
+
+    def remove(self, elem, /) -> None:
+        self._data.remove(elem)
+        self._rstrip()
+
+    def reverse(self):
+        self._data.reverse()
+        self._rstrip()
+
+    def sort(self, *, key=None, reverse=False):
+        self._data.sort(key=key, reverse=reverse)
+        self._rstrip()

v440/_core/Version.py

@@ -0,0 +1,264 @@
+from __future__ import annotations
+
+import typing
+
+import packaging.version
+import scaevola
+
+from v440._core.Local import Local
+from v440._core.Pre import Pre
+from v440._core.Release import Release
+
+from . import utils
+
+
+class Version(scaevola.Scaevola):
+    def __bool__(self):
+        return self != type(self)()
+
+    def __eq__(self, other) -> bool:
+        other = type(self)(other)
+        return self._cmpkey() == other._cmpkey()
+
+    def __hash__(self) -> int:
+        return hash(self._cmpkey())
+
+    def __init__(self, data="0", /, **kwargs) -> None:
+        self.data = data
+        self.update(**kwargs)
+
+    def __le__(self, other) -> bool:
+        other = type(self)(other)
+        return self._cmpkey() <= other._cmpkey()
+
+    def __lt__(self, other) -> bool:
+        other = type(self)(other)
+        return self._cmpkey() < other._cmpkey()
+
+    def __repr__(self) -> str:
+        return "%s(%r)" % (type(self).__name__, str(self))
+
+    def __str__(self) -> str:
+        return self.data
+
+    def _aux(self) -> str:
+        ans = str(self.pre)
+        if self.post is not None:
+            ans += ".post%s" % self.post
+        if self.dev is not None:
+            ans += ".dev%s" % self.dev
+        return ans
+
+    def _cmpkey(self) -> tuple:
+        if self.pre:
+            pre = self.pre.data
+        elif self.post is None and self.dev is not None:
+            pre = "", -1
+        else:
+            pre = "z", float("inf")
+        post = -1 if self.post is None else self.post
+        dev = float("inf") if self.dev is None else self.dev
+        return self.epoch, self.release, pre, post, dev, self.local
+
+    @property
+    def base(self) -> str:
+        if self.epoch:
+            return "%s!%s" % (self.epoch, self.release)
+        else:
+            return str(self.release)
+
+    @base.setter
+    @utils.setterdeco
+    def base(self, v):
+        v = str(v)
+        if "!" in v:
+            self.epoch, self.release = v.split("!")
+        else:
+            self.epoch, self.release = 0, v
+
+    @base.deleter
+    def base(self):
+        del self.epoch
+        del self.release
+
+    def clear(self):
+        del self.public
+        del self.local
+
+    def copy(self):
+        return type(self)(self)
+
+    @property
+    def data(self):
+        return self.format()
+
+    @data.setter
+    @utils.setterdeco
+    def data(self, x):
+        x = str(x)
+        if "+" in x:
+            self.public, self.local = x.split("+")
+        else:
+            self.public, self.local = x, None
+
+    @data.deleter
+    def data(self):
+        del self.public
+        del self.local
+
+    @property
+    def dev(self):
+        return self._dev
+
+    @dev.setter
+    @utils.setterdeco
+    def dev(self, v):
+        v = utils.tolist(v, ".")
+        if len(v) > 2:
+            raise ValueError
+        if len(v) == 0:
+            del self.dev
+            return
+        if len(v) == 1:
+            v = v[0]
+            v = utils.lsplit(v, "dev", "")
+        if v[0] != "dev":
+            raise ValueError
+        v = utils.numeral(v[1])
+        self._dev = v
+
+    @dev.deleter
+    def dev(self):
+        self._dev = None
+
+    @property
+    def epoch(self):
+        return self._epoch
+
+    @epoch.setter
+    @utils.setterdeco
+    def epoch(self, v):
+        v = str(v)
+        v = utils.lsplit(v, "v", "")[1]
+        if v.endswith("!"):
+            v = v[:-1]
+        v = utils.numeral(v)
+        return v
+
+    @epoch.deleter
+    def epoch(self):
+        self._epoch = 0
+
+    def format(self, cutoff=None) -> str:
+        ans = ""
+        if self.epoch:
+            ans += "%s!" % self.epoch
+        ans += self.release.format(cutoff=cutoff)
+        ans += self._aux()
+        if self.local:
+            ans += "+%s" % self.local
+        return ans
+
+    def is_prerelease(self) -> bool:
+        return self.dev is not None or self.pre is not None
+
+    def is_postrelease(self) -> bool:
+        return self.post is not None
+
+    def is_devrelease(self) -> bool:
+        return self.dev is not None
+
+    @property
+    def local(self) -> str:
+        return self._local
+
+    @local.setter
+    @utils.setterdeco
+    def local(self, v):
+        self._local = Local(v)
+
+    @local.deleter
+    def local(self):
+        self._local = Local()
+
+    def packaging(self):
+        return packaging.version.Version(self.data)
+
+    @property
+    def post(self):
+        return self._post
+
+    @post.setter
+    @utils.setterdeco
+    def post(self, v):
+        v = utils.tolist(v, ".")
+        if len(v) > 2:
+            raise ValueError
+        if len(v) == 0:
+            del self.post
+            return
+        prefices = "post", "rev", "r", ""
+        if len(v) == 1:
+            v = utils.lsplit(v[0], *prefices)
+        elif v[0] not in prefices:
+            raise ValueError
+        v = utils.numeral(v[1])
+        self._post = v
+
+    @post.deleter
+    def post(self):
+        self._post = None
+
+    @property
+    def pre(self):
+        return self._pre
+
+    @pre.setter
+    @utils.setterdeco
+    def pre(self, data, /):
+        self._pre = Pre(data)
+
+    @pre.deleter
+    def pre(self):
+        self._pre = Pre()
+
+    @property
+    def public(self) -> str:
+        return self.base + self._aux()
+
+    @public.setter
+    @utils.setterdeco
+    def public(self, v):
+        v = str(v).lower().strip()
+        d = utils.Pattern.PUBLIC.regex.search(v).groupdict()
+        names = "epoch release pre post dev".split()
+        for n in names:
+            setattr(self, n, d[n])
+
+    @public.deleter
+    def public(self):
+        self.public = "0"
+
+    @property
+    def release(self) -> Release:
+        return self._release
+
+    @release.setter
+    @utils.setterdeco
+    def release(self, v):
+        self._release = Release(v)
+
+    @release.deleter
+    def release(self):
+        self._release = Release()
+
+    def update(self, **kwargs):
+        for k, v in kwargs.items():
+            attr = getattr(type(self), k)
+            if isinstance(attr, property):
+                setattr(self, k, v)
+                continue
+            e = "%r is not a property"
+            e %= k
+            e = AttributeError(e)
+            raise e

v440/_core/__init__.py

@@ -0,0 +1,2 @@
+from v440._core.utils import VersionError
+from v440._core.Version import Version

v440/_core/utils.py

@@ -0,0 +1,196 @@
+from __future__ import annotations
+
+import enum
+import functools
+import inspect
+import re
+import string
+import typing
+
+SEGCHARS = string.ascii_lowercase + string.digits
+
+
+class EMPTY: ...
+
+
+def compclass(innerclass):
+    return functools.partial(compclass_core, innerclass)
+
+
+def compclass_core(innerclass, outerclass):
+    for n in dir(innerclass):
+        if not (isnunder(n) or ismagic(n)):
+            continue
+        i = getattr(innerclass, n)
+        if type(i) is type:
+            continue
+        if not callable(i):
+            continue
+        o = getattr(outerclass, n, EMPTY)
+        o = compclass_outerfunc(n, o)
+        if isnunder(n):
+            o = functools.wraps(i)(o)
+        setattr(outerclass, n, o)
+    return outerclass
+
+
+def compclass_outerfunc(n, gotten, /):
+    if gotten is not EMPTY:
+        return gotten
+
+    def o(self, *args, **kwargs):
+        f = getattr(self._data, n)
+        y = f(*args, **kwargs)
+        return y
+
+    return o
+
+
+def ismagic(name):
+    name = str(name)
+    if len(name) < 5:
+        return False
+    if not name.startswith("__"):
+        return False
+    if not name.endswith("__"):
+        return False
+    if name.startswith("___"):
+        return False
+    if name.endswith("___"):
+        return False
+    return True
+
+
+def isnunder(name):
+    name = str(name)
+    return not name.startswith("_")
+
+
+def literal(value, /):
+    e = "%r is not a valid literal segment"
+    e = VersionError(e % value)
+    try:
+        x = segment(value)
+    except:
+        raise e
+    if type(x) is str:
+        return x
+    raise e
+
+
+def lsplit(value: str, *prefices):
+    for p in prefices:
+        if value.startswith(p):
+            return p, value[len(p) :]
+    raise ValueError
+
+
+def numeral(value, /):
+    e = "%r is not a valid numeral segment"
+    e = VersionError(e % value)
+    try:
+        x = segment(value)
+    except:
+        raise e
+    if type(x) is int:
+        return x
+    if x == "":
+        return 0
+    raise e
+
+
+def segment(value, /):
+    e = "%r is not a valid segment"
+    e = VersionError(e % value)
+    try:
+        x = str(value).lower().strip()
+    except:
+        raise e
+    if x.strip(SEGCHARS):
+        raise e
+    try:
+        return int(x)
+    except:
+        return x
+
+
+def setterdeco(old, /):
+    @functools.wraps(old)
+    def new(self, value, /):
+        if value is None:
+            delattr(self, old.__name__)
+            return
+        try:
+            old(self, value)
+        except VersionError:
+            raise
+        except:
+            e = "%r is an invalid value for %r"
+            e %= (value, old.__name__)
+            raise VersionError(e)
+
+    return new
+
+
+def todata(value, *args):
+    try:
+        return tolist(value, *args)
+    except VersionError:
+        raise
+    except:
+        e = "%r is an invalid value for %r"
+        e %= (value, "data")
+        raise VersionError(e)
+
+
+def toindex(value, /):
+    ans = value.__index__()
+    if type(ans) is not int:
+        raise TypeError("__index__ returned non-int (type %s)" % type(ans).__name__)
+    return ans
+
+
+def tolist(value, prefix):
+    if value is None:
+        return
+    if not issubclass(type(value), str) and hasattr(value, "__iter__"):
+        return list(value)
+    value = str(value).lower()
+    value = value.replace("-", ".")
+    value = value.replace("_", ".")
+    value = lsplit(value, prefix, "")[1]
+    if value == "":
+        return []
+    value = value.split(".")
+    return value
+
+
+class Pattern(enum.StrEnum):
+    EPOCH = r"(?:(?P<epoch>[0-9]+)!)?"
+    RELEASE = r"(?P<release>[0-9]+(?:\.[0-9]+)*)"
+    PRE = r"""
+        (?P<pre>                                          
+            [-_\.]?
+            (?P<pre_l>alpha|a|beta|b|preview|pre|c|rc)
+            [-_\.]?
+            (?P<pre_n>[0-9]+)?
+        )?"""
+    POST = r"""
+        (?P<post>                                         
+            (?:-(?:[0-9]+))
+            |
+            (?: [-_\.]? (?:post|rev|r) [-_\.]? (?:[0-9]+)? )
+        )?"""
+    DEV = r"""(?P<dev> [-_\.]? dev [-_\.]? (?:[0-9]+)? )?"""
+    LOCAL = r"""(?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?"""
+    PUBLIC = f"v? {EPOCH} {RELEASE} {PRE} {POST} {DEV}"
+
+    @functools.cached_property
+    def regex(self):
+        p = self.value
+        p = r"^" + p + r"$"
+        ans = re.compile(p, re.VERBOSE)
+        return ans
+
+
+class VersionError(ValueError): ...

v440-0.2.0.dist-info/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Johannes
+
+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.

v440-0.2.0.dist-info/METADATA

@@ -0,0 +1,74 @@
+Metadata-Version: 2.1
+Name: v440
+Version: 0.2.0
+Summary: mutable version objects
+Author-email: Johannes <johannes-programming@mailfence.com>
+License: The MIT License (MIT)
+        
+        Copyright (c) 2024 Johannes
+        
+        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.
+Project-URL: Download, https://pypi.org/project/v440/#files
+Project-URL: Source, https://github.com/johannes-programming/v440
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.12
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+Requires-Dist: packaging >=23.2
+Requires-Dist: scaevola >=1.0.5
+
+====
+v440
+====
+
+Overview
+--------
+
+mutable version objects in accordance with PEP440
+
+Installation
+------------
+
+To install v440, you can use `pip`. Open your terminal and run:
+
+.. code-block:: bash
+
+    pip install v440
+
+License
+-------
+
+This project is licensed under the MIT License.
+
+Links
+-----
+
+* `Download <https://pypi.org/project/v440/#files>`_
+* `Source <https://github.com/johannes-programming/v440>`_
+
+Credits
+-------
+
+- Author: Johannes
+- Email: johannes-programming@mailfence.com
+
+Thank you for using v440!

v440-0.2.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+v440/__init__.py,sha256=MQrVNWvZoxumw3SE5XBnGWje_gQ7V_DvfDLv29UX0SE,25
+v440/_core/Local.py,sha256=P_r3ZYlN_Ifn3Qp15wYa24y0bPvgksVHgrwwx4lyuY8,2820
+v440/_core/Pre.py,sha256=yOA2bst5PdFwjcJhBHHC_a9XwdmvOnlwJhauXEYS0CI,3195
+v440/_core/Release.py,sha256=-tEpa1uTQqK9vAt2WdOMKapvH0kT50_LSXUYOGjaPJo,6106
+v440/_core/Version.py,sha256=BcnxNQvoA5CGg-3uBhg6BjcfHbU94_tIy6CSqAK_ETU,6114
+v440/_core/__init__.py,sha256=uYjdaudy0Sc4ys1eoI8c7-WvW5394p5UNw2BI_thrRA,81
+v440/_core/utils.py,sha256=q2sgR4nKSEuwjVgIk5kVdVBkoZ-zmGOEynGdspFwIpQ,4369
+v440-0.2.0.dist-info/LICENSE.txt,sha256=QwqYepQwTN5xG57cngKt6xxYD9z9hw9d3lcI8zSLiNg,1074
+v440-0.2.0.dist-info/METADATA,sha256=E0zZRIJP5VRvmTqKiCIJJ_9k_qW3lhxtpFR5NBULG94,2382
+v440-0.2.0.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
+v440-0.2.0.dist-info/top_level.txt,sha256=0KhvBmvlzcE4QlmK9pkVo1pXR2q-YDKG5Bj5yIXmWTE,5
+v440-0.2.0.dist-info/RECORD,,

v440-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (74.1.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

v440-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+v440