omdev 0.0.0.dev7__py3-none-any.whl

omdev/exts/_distutils/version.py

@@ -0,0 +1,308 @@
+"""
+Provides classes to represent module version numbers (one class for each style of version numbering).  There are
+currently two such classes implemented: StrictVersion and LooseVersion.
+
+Every version number class implements the following interface:
+  * the 'parse' method takes a string and parses it to some internal representation; if the string is an invalid version
+    number, 'parse' raises a ValueError exception
+  * the class constructor takes an optional string argument which, if supplied, is passed to 'parse'
+  * __str__ reconstructs the string that was passed to 'parse' (or an equivalent string -- ie. one that will generate an
+    equivalent version number instance)
+  * __repr__ generates Python code to recreate the version number instance
+  * _cmp compares the current instance with either another instance of the same class or a string (which will be parsed
+    to an instance of the same class, thus must follow the same rules)
+"""
+import abc
+import contextlib
+import re
+import warnings
+
+
+@contextlib.contextmanager
+def suppress_known_deprecation():
+    with warnings.catch_warnings(record=True) as ctx:
+        warnings.filterwarnings(
+            action='default',
+            category=DeprecationWarning,
+            message='distutils Version classes are deprecated.',
+        )
+        yield ctx
+
+
+class Version(abc.ABC):
+    """
+    Abstract base class for version numbering classes.  Just provides constructor (__init__) and reproducer (__repr__),
+    because those seem to be the same for all version numbering classes; and route rich comparisons to _cmp.
+    """
+
+    def __init__(self, vstring=None):
+        if vstring:
+            self.parse(vstring)
+        warnings.warn(
+            'distutils Version classes are deprecated. Use packaging.version instead.',
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+    @abc.abstractmethod
+    def parse(self, vstring):
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def _cmp(self, other):
+        raise NotImplementedError
+
+    def __repr__(self):
+        return f"{self.__class__.__name__} ('{self!s}')"
+
+    def __eq__(self, other):
+        c = self._cmp(other)
+        if c is NotImplemented:
+            return c
+        return c == 0
+
+    def __lt__(self, other):
+        c = self._cmp(other)
+        if c is NotImplemented:
+            return c
+        return c < 0
+
+    def __le__(self, other):
+        c = self._cmp(other)
+        if c is NotImplemented:
+            return c
+        return c <= 0
+
+    def __gt__(self, other):
+        c = self._cmp(other)
+        if c is NotImplemented:
+            return c
+        return c > 0
+
+    def __ge__(self, other):
+        c = self._cmp(other)
+        if c is NotImplemented:
+            return c
+        return c >= 0
+
+
+# Interface for version-number classes -- must be implemented by the following classes (the concrete ones -- Version
+# should be treated as an abstract class).
+#    __init__ (string)  - create and take same action as 'parse' (string parameter is optional)
+#    parse (string)     - convert a string representation to whatever internal representation is appropriate for this
+#                         style of version numbering
+#    __str__ (self)     - convert back to a string; should be very similar (if not identical to) the string supplied to
+#                         parse
+#    __repr__ (self)    - generate Python code to recreate the instance
+#    _cmp (self, other) - compare two version numbers ('other' may be an unparsed version string, or another instance of
+#                        your version class)
+
+
+class StrictVersion(Version):
+    """
+    Version numbering for anal retentives and software idealists. Implements the standard interface for version number
+    classes as described above.  A version number consists of two or three dot-separated numeric components, with an
+    optional "pre-release" tag on the end.  The pre-release tag consists of the letter 'a' or 'b' followed by a number.
+     If the numeric components of two version numbers are equal, then one with a pre-release tag will always be deemed
+     earlier (lesser) than one without.
+
+    The following are valid version numbers (shown in the order that would be obtained by sorting according to the
+    supplied cmp function):
+
+        0.4       0.4.0  (these two are equivalent)
+        0.4.1
+        0.5a1
+        0.5b3
+        0.5
+        0.9.6
+        1.0
+        1.0.4a3
+        1.0.4b1
+        1.0.4
+
+    The following are examples of invalid version numbers:
+
+        1
+        2.7.2.2
+        1.3.a4
+        1.3pl1
+        1.3c4
+
+    The rationale for this version numbering system will be explained in the distutils documentation.
+    """
+
+    version_re = re.compile(r'^(\d+) \. (\d+) (\. (\d+))? ([ab](\d+))?$', re.VERBOSE | re.ASCII)
+
+    version: tuple[int, ...]
+    prerelease: tuple[str, int] | None
+
+    def parse(self, vstring):
+        match = self.version_re.match(vstring)
+        if not match:
+            raise ValueError(f"invalid version number '{vstring}'")
+
+        (major, minor, patch, prerelease, prerelease_num) = match.group(1, 2, 4, 5, 6)
+
+        if patch:
+            self.version = tuple(map(int, [major, minor, patch]))
+        else:
+            self.version = (*map(int, [major, minor]), 0)
+
+        if prerelease:
+            self.prerelease = (prerelease[0], int(prerelease_num))
+        else:
+            self.prerelease = None
+
+    def __str__(self):
+        if self.version[2] == 0:
+            vstring = '.'.join(map(str, self.version[0:2]))
+        else:
+            vstring = '.'.join(map(str, self.version))
+
+        if self.prerelease:
+            vstring = vstring + self.prerelease[0] + str(self.prerelease[1])
+
+        return vstring
+
+    def _cmp(self, other):
+        if isinstance(other, str):
+            with suppress_known_deprecation():
+                other = StrictVersion(other)
+        elif not isinstance(other, StrictVersion):
+            return NotImplemented
+
+        if self.version == other.version:
+            # versions match; pre-release drives the comparison
+            return self._cmp_prerelease(other)
+
+        return -1 if self.version < other.version else 1
+
+    def _cmp_prerelease(self, other):
+        """
+        case 1: self has prerelease, other doesn't; other is greater
+        case 2: self doesn't have prerelease, other does: self is greater
+        case 3: both or neither have prerelease: compare them!
+        """
+        if self.prerelease and not other.prerelease:
+            return -1
+        elif not self.prerelease and other.prerelease:
+            return 1
+
+        if self.prerelease == other.prerelease:
+            return 0
+        elif self.prerelease < other.prerelease:
+            return -1
+        else:
+            return 1
+
+
+# end class StrictVersion
+
+
+# The rules according to Greg Stein:
+# 1) a version number has 1 or more numbers separated by a period or by sequences of letters. If only periods, then
+#    these are compared left-to-right to determine an ordering.
+# 2) sequences of letters are part of the tuple for comparison and are compared lexicographically
+# 3) recognize the numeric components may have leading zeroes
+#
+# The LooseVersion class below implements these rules: a version number string is split up into a tuple of integer and
+# string components, and comparison is a simple tuple comparison.  This means that version numbers behave in a
+# predictable and obvious way, but a way that might not necessarily be how people *want* version numbers to behave.
+# There wouldn't be a problem if people could stick to purely numeric version numbers: just split on period and compare
+# the numbers as tuples. However, people insist on putting letters into their version numbers; the most common purpose
+# seems to be:
+#   - indicating a "pre-release" version ('alpha', 'beta', 'a', 'b', 'pre', 'p')
+#   - indicating a post-release patch ('p', 'pl', 'patch')
+# but of course this can't cover all version number schemes, and there's no way to know what a programmer means without
+# asking him.
+#
+# The problem is what to do with letters (and other non-numeric characters) in a version number.  The current
+# implementation does the obvious and predictable thing: keep them as strings and compare lexically within a tuple
+# comparison.  This has the desired effect if an appended letter sequence implies something "post-release": eg. "0.99" <
+# "0.99pl14" < "1.0", and "5.001" < "5.001m" < "5.002".
+#
+# However, if letters in a version number imply a pre-release version, the "obvious" thing isn't correct.  Eg. you would
+# expect that "1.5.1" < "1.5.2a2" < "1.5.2", but under the tuple/lexical comparison implemented here, this just isn't
+# so.
+#
+# Two possible solutions come to mind.  The first is to tie the comparison algorithm to a particular set of semantic
+# rules, as has been done in the StrictVersion class above.  This works great as long as everyone can go along with
+# bondage and discipline.  Hopefully a (large) subset of Python module programmers will agree that the particular
+# flavour of bondage and discipline provided by StrictVersion provides enough benefit to be worth using, and will submit
+# their version numbering scheme to its domination.  The free-thinking anarchists in the lot will never give in, though,
+# and something needs to be done to accommodate them.
+#
+# Perhaps a "moderately strict" version class could be implemented that lets almost anything slide (syntactically), and
+# makes some heuristic assumptions about non-digits in version number strings.  This could sink into special-case-hell,
+# though; if I was as talented and idiosyncratic as Larry Wall, I'd go ahead and implement a class that somehow knows
+# that "1.2.1" < "1.2.2a2" < "1.2.2" < "1.2.2pl3", and is just as happy dealing with things like "2g6" and "1.13++".  I
+# don't think I'm smart enough to do it right though.
+#
+# In any case, I've coded the test suite for this module (see ../test/test_version.py) specifically to fail on things
+# like comparing "1.2a2" and "1.2".  That's not because the *code* is doing anything wrong, it's because the simple,
+# obvious design doesn't match my complicated, hairy expectations for real-world version numbers.  It would be a snap to
+# fix the test suite to say, "Yep, LooseVersion does the Right Thing" (ie. the code matches the conception).  But I'd
+# rather have a conception that matches common notions about version numbers.
+
+
+class LooseVersion(Version):
+    """
+    Version numbering for anarchists and software realists. Implements the standard interface for version number classes
+    as described above.  A version number consists of a series of numbers, separated by either periods or strings of
+    letters.  When comparing version numbers, the numeric components will be compared numerically, and the alphabetic
+    components lexically.  The following are all valid version numbers, in no particular order:
+
+        1.5.1
+        1.5.2b2
+        161
+        3.10a
+        8.02
+        3.4j
+        1996.07.12
+        3.2.pl0
+        3.1.1.6
+        2g6
+        11g
+        0.960923
+        2.2beta29
+        1.13++
+        5.5.kw
+        2.0b1pl0
+
+    In fact, there is no such thing as an invalid version number under this scheme; the rules for comparison are simple
+    and predictable, but may not always give the results you want (for some definition of "want").
+    """
+
+    component_re = re.compile(r'(\d+ | [a-z]+ | \.)', re.VERBOSE)
+
+    def parse(self, vstring):
+        # I've given up on thinking I can reconstruct the version string from the parsed tuple -- so I just store the
+        # string here for use by __str__
+        self.vstring = vstring
+        components = [x for x in self.component_re.split(vstring) if x and x != '.']
+        for i, obj in enumerate(components):
+            with contextlib.suppress(ValueError):
+                components[i] = int(obj)
+
+        self.version = components
+
+    def __str__(self):
+        return self.vstring
+
+    def __repr__(self) -> str:
+        return f"LooseVersion ('{self!s}')"
+
+    def _cmp(self, other):
+        if isinstance(other, str):
+            other = LooseVersion(other)
+        elif not isinstance(other, LooseVersion):
+            return NotImplemented
+
+        if self.version == other.version:
+            return 0
+        if self.version < other.version:
+            return -1
+        if self.version > other.version:
+            return 1
+
+        return None

omdev/exts/build.py

@@ -0,0 +1,43 @@
+import os.path
+import sys
+import sysconfig
+
+from . import _distutils as du
+
+
+def build_ext(
+        fullname: str,
+        src_path: str,
+) -> str:
+    extra_link_args: list[str] = []
+    if sys.platform == 'darwin':
+        extra_link_args.append('-Wl,-no_fixup_chains')
+
+    ext = du.Extension(
+        fullname,
+        sources=[src_path],
+        include_dirs=[os.path.dirname(src_path)],
+        extra_compile_args=[
+            *(['-std=c++20'] if any(src_path.endswith(sf) for sf in ('cc', 'cpp')) else []),
+        ],
+        extra_link_args=extra_link_args,
+        undef_macros=['BARF'],
+    )
+
+    cmd_obj = du.BuildExt(du.BuildExt.Options(
+        inplace=True,
+        debug=True,
+    ))
+    cmd_obj.build_extension(ext)
+
+    so_path = os.path.join(
+        os.path.dirname(src_path),
+        ''.join([
+            fullname.rpartition('.')[2],
+            '.',
+            sysconfig.get_config_var('SOABI'),
+            sysconfig.get_config_var('SHLIB_SUFFIX'),
+        ]),
+    )
+
+    return so_path

omdev/exts/cmake.py

@@ -0,0 +1,195 @@
+"""
+TODO:
+ - symlink headers, included src files (hamt_impl, ...)
+ - point / copy output to dst dirs
+ - libs
+  - ..
+   - pybind
+   - catch2?
+   - json? https://github.com/nlohmann/json
+  - FindPackages? FetchContent? built_ext won't have that
+  - move omml git / data retriever stuff into omdev, get just the one header file from git via sha?
+
+==
+
+Done:
+ - https://intellij-support.jetbrains.com/hc/en-us/community/posts/206608485-Multiple-Jetbrain-IDE-sharing-the-same-project-directory really?
+  - aight, generate a whole cmake subdir with symlinks to src files lol
+
+"""  # noqa
+import io
+import os.path
+import shutil
+import sys
+import sysconfig
+
+from omlish import check
+
+from .. import cmake
+
+
+def _main() -> None:
+    # py_root = '$ENV{HOME}/.pyenv/versions/3.11.8/'
+
+    prj_root = os.path.abspath(os.getcwd())
+    if not os.path.isfile(os.path.join(prj_root, 'pyproject.toml')):
+        raise Exception('Must be run in project root')
+
+    cmake_dir = os.path.join(prj_root, 'cmake')
+    if os.path.exists(cmake_dir):
+        for e in os.listdir(cmake_dir):
+            if e == '.idea':
+                continue
+            ep = os.path.join(cmake_dir, e)
+            if os.path.isfile(ep):
+                os.unlink(ep)
+            else:
+                shutil.rmtree(ep)
+    else:
+        os.mkdir(cmake_dir)
+
+    with open(os.path.join(cmake_dir, '.gitignore'), 'w') as f:
+        f.write('\n'.join(sorted(['/cmake-*', '/build'])))
+
+    if os.path.isdir(os.path.join(cmake_dir, '.idea')):
+        with open(os.path.join(cmake_dir, '.idea', '.name'), 'w') as f:
+            f.write('omlish')
+
+    venv_exe = sys.executable
+    venv_root = os.path.abspath(os.path.join(os.path.dirname(venv_exe), '..'))
+    real_exe = os.path.realpath(venv_exe)
+    py_root = os.path.abspath(os.path.join(os.path.dirname(real_exe), '..'))
+    py_sfx = '.'.join(map(str, sys.version_info[:2]))
+
+    out = io.StringIO()
+    gen = cmake.CmakeGen(out)
+
+    prj_name = 'omlish'
+    var_prefix = prj_name.upper()
+
+    gen.write(gen.preamble)
+    gen.write('')
+
+    gen.write(f'project({prj_name})')
+    gen.write('')
+
+    def sep_grps(*ls):
+        # itertools.interleave? or smth?
+        o = []
+        for i, l in enumerate(ls):
+            if not l:
+                continue
+            if i:
+                o.append('')
+            o.extend(check.not_isinstance(l, str))
+        return o
+
+    gen.write_var(cmake.Var(
+        f'{var_prefix}_INCLUDE_DIRECTORIES',
+        sep_grps(
+            [f'{venv_root}/include'],
+            [f'{py_root}/include/python{py_sfx}'],
+            [
+                # $ENV{HOME}/src/python/cpython
+                # $ENV{HOME}/src/python/cpython/include
+            ],
+        ),
+    ))
+
+    gen.write_var(cmake.Var(
+        f'{var_prefix}_COMPILE_OPTIONS',
+        sep_grps(
+            [
+                '-Wsign-compare',
+                '-Wunreachable-code',
+                '-DNDEBUG',
+                '-g',
+                '-fwrapv',
+                '-O3',
+                '-Wall',
+            ],
+            [
+                '-g',
+                '-c',
+            ],
+            ['-std=c++20'],
+        ),
+    ))
+
+    gen.write_var(cmake.Var(
+        f'{var_prefix}_LINK_DIRECTORIES',
+        sep_grps(
+            [f'{py_root}/lib'],
+            # ['$ENV{HOME}/src/python/cpython'],
+        ),
+    ))
+
+    gen.write_var(cmake.Var(
+        f'{var_prefix}_LINK_LIBRARIES',
+        sep_grps(
+            *([[
+                '-bundle',
+                '"-undefined dynamic_lookup"',
+            ]] if sys.platform == 'darwin' else []),
+        ),
+    ))
+
+    for ext_src in [
+        'omdev/exts/_boilerplate.cc',
+        'x/dev/c/junk.cc',
+        'x/dev/c/_uuid.cc',
+    ]:
+        ext_name = ext_src.rpartition('.')[0].replace('/', '__')
+        so_name = ''.join([
+            os.path.basename(ext_src).split('.')[0],
+            '.',
+            sysconfig.get_config_var('SOABI'),
+            sysconfig.get_config_var('SHLIB_SUFFIX'),
+        ])
+
+        sl = os.path.join(cmake_dir, ext_src)
+        sal = os.path.abspath(sl)
+        sd = os.path.dirname(sal)
+        os.makedirs(sd, exist_ok=True)
+        rp = os.path.relpath(os.path.abspath(ext_src), sd)
+        os.symlink(rp, sal)
+
+        gen.write_target(cmake.ModuleLibrary(
+            ext_name,
+            src_files=[
+                sl,
+            ],
+            include_dirs=[
+                f'${{{var_prefix}_INCLUDE_DIRECTORIES}}',
+            ],
+            compile_opts=[
+                f'${{{var_prefix}_COMPILE_OPTIONS}}',
+            ],
+            link_dirs=[
+                f'${{{var_prefix}_LINK_DIRECTORIES}}',
+            ],
+            link_libs=[
+                f'${{{var_prefix}_LINK_LIBRARIES}}',
+            ],
+            extra_cmds=[
+                cmake.Command(
+                    'add_custom_command',
+                    ['TARGET', ext_name, 'POST_BUILD'],
+                    [
+                        ' '.join([
+                            'COMMAND ${CMAKE_COMMAND} -E ',
+                            f'copy $<TARGET_FILE_NAME:{ext_name}> ../../{os.path.dirname(ext_src)}/{so_name}',
+                        ]),
+                        'COMMAND_EXPAND_LISTS',
+                    ],
+                ),
+            ],
+        ))
+
+    print(out.getvalue())
+    with open(os.path.join(cmake_dir, 'CMakeLists.txt'), 'w') as f:
+        f.write(out.getvalue())
+
+
+if __name__ == '__main__':
+    _main()

omdev/exts/importhook.py

@@ -0,0 +1,88 @@
+"""
+TODO:
+ - remove imp
+ - whitelist packages
+"""
+import dataclasses as dc
+import importlib
+import importlib.abc
+import importlib.machinery
+import os.path
+import sys
+import types
+import typing as ta
+
+from . import build
+
+
+def load_dynamic(name: str, path: str) -> types.ModuleType:
+    import importlib.machinery
+    loader = importlib.machinery.ExtensionFileLoader(name, path)
+
+    # Issue #24748: Skip the sys.modules check in _load_module_shim; always load new extension
+    spec = importlib.machinery.ModuleSpec(name=name, loader=loader, origin=path)
+
+    import importlib._bootstrap  # FIXME:  # noqa
+    return importlib._bootstrap._load(spec)  # noqa
+
+
+class CExtensionLoader(importlib.abc.Loader):
+
+    def __init__(self, fullname: str, path: str) -> None:
+        super().__init__()
+
+        self._fullname = fullname
+        self._path = path
+
+    def load_module(self, fullname: str) -> types.ModuleType:
+        so_path = build.build_ext(fullname, self._path)
+        return load_dynamic(self._fullname, so_path)
+
+
+LoaderDetails: ta.TypeAlias = tuple[type[importlib.abc.Loader], list[str]]
+loader_details = (CExtensionLoader, ['.c', '.cc', '.cpp', '.cxx'])
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class FileFinderPathHook:
+    lds: ta.Sequence[LoaderDetails]
+
+    def __call__(self, path: str) -> importlib.machinery.FileFinder:
+        if not path:
+            path = os.getcwd()
+        if not os.path.isdir(path):
+            raise ImportError('only directories are supported', path=path)
+        return importlib.machinery.FileFinder(path, *self.lds)
+
+
+def _is_c_loader(h: ta.Any) -> bool:
+    return (
+        isinstance(h, FileFinderPathHook) and
+        h.lds == [loader_details]
+    )
+
+
+def is_installed() -> bool:
+    return any(h for h in sys.path_hooks if _is_c_loader(h))
+
+
+def _install(*, flush: bool = False) -> None:
+    sys.path_hooks.insert(0, FileFinderPathHook([loader_details]))
+    sys.path_importer_cache.clear()
+    if flush:
+        importlib.invalidate_caches()
+
+
+def install(*, flush: bool = False) -> None:
+    if not is_installed():
+        _install(flush=flush)
+
+
+def uninstall(*, flush: bool = False) -> None:
+    sys.path_hooks = [h for h in sys.path_hooks if not _is_c_loader(h)]
+    sys.path_importer_cache.clear()
+    if flush:
+        importlib.invalidate_caches()