quarchpy 2.1.14.dev4__py2.py3-none-any.whl → 2.1.14.dev5__py2.py3-none-any.whl

quarchpy/venv/Lib/site-packages/wheel/wheelfile.py

@@ -0,0 +1,181 @@
+from __future__ import print_function
+
+import csv
+import hashlib
+import os.path
+import re
+import stat
+import sys
+import time
+from collections import OrderedDict
+from distutils import log as logger
+from zipfile import ZIP_DEFLATED, ZipInfo, ZipFile
+
+from wheel.cli import WheelError
+from wheel.util import urlsafe_b64decode, as_unicode, native, urlsafe_b64encode, as_bytes, StringIO
+
+if sys.version_info >= (3,):
+    from io import TextIOWrapper
+
+    def read_csv(fp):
+        return csv.reader(TextIOWrapper(fp, newline='', encoding='utf-8'))
+else:
+    def read_csv(fp):
+        for line in csv.reader(fp):
+            yield [column.decode('utf-8') for column in line]
+
+# Non-greedy matching of an optional build number may be too clever (more
+# invalid wheel filenames will match). Separate regex for .dist-info?
+WHEEL_INFO_RE = re.compile(
+    r"""^(?P<namever>(?P<name>.+?)-(?P<ver>.+?))(-(?P<build>\d[^-]*))?
+     -(?P<pyver>.+?)-(?P<abi>.+?)-(?P<plat>.+?)\.whl$""",
+    re.VERBOSE)
+
+
+def get_zipinfo_datetime(timestamp=None):
+    # Some applications need reproducible .whl files, but they can't do this without forcing
+    # the timestamp of the individual ZipInfo objects. See issue #143.
+    timestamp = int(os.environ.get('SOURCE_DATE_EPOCH', timestamp or time.time()))
+    return time.gmtime(timestamp)[0:6]
+
+
+class WheelFile(ZipFile):
+    """A ZipFile derivative class that also reads SHA-256 hashes from
+    .dist-info/RECORD and checks any read files against those.
+    """
+
+    _default_algorithm = hashlib.sha256
+
+    def __init__(self, file, mode='r', compression=ZIP_DEFLATED):
+        basename = os.path.basename(file)
+        self.parsed_filename = WHEEL_INFO_RE.match(basename)
+        if not basename.endswith('.whl') or self.parsed_filename is None:
+            raise WheelError("Bad wheel filename {!r}".format(basename))
+
+        ZipFile.__init__(self, file, mode, compression=compression, allowZip64=True)
+
+        self.dist_info_path = '{}.dist-info'.format(self.parsed_filename.group('namever'))
+        self.record_path = self.dist_info_path + '/RECORD'
+        self._file_hashes = OrderedDict()
+        self._file_sizes = {}
+        if mode == 'r':
+            # Ignore RECORD and any embedded wheel signatures
+            self._file_hashes[self.record_path] = None, None
+            self._file_hashes[self.record_path + '.jws'] = None, None
+            self._file_hashes[self.record_path + '.p7s'] = None, None
+
+            # Fill in the expected hashes by reading them from RECORD
+            try:
+                record = self.open(self.record_path)
+            except KeyError:
+                raise WheelError('Missing {} file'.format(self.record_path))
+
+            with record:
+                for line in read_csv(record):
+                    path, hash_sum, size = line
+                    if not hash_sum:
+                        continue
+
+                    algorithm, hash_sum = hash_sum.split(u'=')
+                    try:
+                        hashlib.new(algorithm)
+                    except ValueError:
+                        raise WheelError('Unsupported hash algorithm: {}'.format(algorithm))
+
+                    if algorithm.lower() in {'md5', 'sha1'}:
+                        raise WheelError(
+                            'Weak hash algorithm ({}) is not permitted by PEP 427'
+                            .format(algorithm))
+
+                    self._file_hashes[path] = (
+                        algorithm, urlsafe_b64decode(hash_sum.encode('ascii')))
+
+    def open(self, name_or_info, mode="r", pwd=None):
+        def _update_crc(newdata, eof=None):
+            if eof is None:
+                eof = ef._eof
+                update_crc_orig(newdata)
+            else:  # Python 2
+                update_crc_orig(newdata, eof)
+
+            running_hash.update(newdata)
+            if eof and running_hash.digest() != expected_hash:
+                raise WheelError("Hash mismatch for file '{}'".format(native(ef_name)))
+
+        ef_name = as_unicode(name_or_info.filename if isinstance(name_or_info, ZipInfo)
+                             else name_or_info)
+        if mode == 'r' and not ef_name.endswith('/') and ef_name not in self._file_hashes:
+            raise WheelError("No hash found for file '{}'".format(native(ef_name)))
+
+        ef = ZipFile.open(self, name_or_info, mode, pwd)
+        if mode == 'r' and not ef_name.endswith('/'):
+            algorithm, expected_hash = self._file_hashes[ef_name]
+            if expected_hash is not None:
+                # Monkey patch the _update_crc method to also check for the hash from RECORD
+                running_hash = hashlib.new(algorithm)
+                update_crc_orig, ef._update_crc = ef._update_crc, _update_crc
+
+        return ef
+
+    def write_files(self, base_dir):
+        logger.info("creating '%s' and adding '%s' to it", self.filename, base_dir)
+        deferred = []
+        for root, dirnames, filenames in os.walk(base_dir):
+            # Sort the directory names so that `os.walk` will walk them in a
+            # defined order on the next iteration.
+            dirnames.sort()
+            for name in sorted(filenames):
+                path = os.path.normpath(os.path.join(root, name))
+                if os.path.isfile(path):
+                    arcname = os.path.relpath(path, base_dir).replace(os.path.sep, '/')
+                    if arcname == self.record_path:
+                        pass
+                    elif root.endswith('.dist-info'):
+                        deferred.append((path, arcname))
+                    else:
+                        self.write(path, arcname)
+
+        deferred.sort()
+        for path, arcname in deferred:
+            self.write(path, arcname)
+
+    def write(self, filename, arcname=None, compress_type=None):
+        with open(filename, 'rb') as f:
+            st = os.fstat(f.fileno())
+            data = f.read()
+
+        zinfo = ZipInfo(arcname or filename, date_time=get_zipinfo_datetime(st.st_mtime))
+        zinfo.external_attr = (stat.S_IMODE(st.st_mode) | stat.S_IFMT(st.st_mode)) << 16
+        zinfo.compress_type = compress_type or self.compression
+        self.writestr(zinfo, data, compress_type)
+
+    def writestr(self, zinfo_or_arcname, bytes, compress_type=None):
+        ZipFile.writestr(self, zinfo_or_arcname, bytes, compress_type)
+        fname = (zinfo_or_arcname.filename if isinstance(zinfo_or_arcname, ZipInfo)
+                 else zinfo_or_arcname)
+        logger.info("adding '%s'", fname)
+        if fname != self.record_path:
+            hash_ = self._default_algorithm(bytes)
+            self._file_hashes[fname] = hash_.name, native(urlsafe_b64encode(hash_.digest()))
+            self._file_sizes[fname] = len(bytes)
+
+    def close(self):
+        # Write RECORD
+        if self.fp is not None and self.mode == 'w' and self._file_hashes:
+            data = StringIO()
+            writer = csv.writer(data, delimiter=',', quotechar='"', lineterminator='\n')
+            writer.writerows((
+                (
+                    fname,
+                    algorithm + "=" + hash_,
+                    self._file_sizes[fname]
+                )
+                for fname, (algorithm, hash_) in self._file_hashes.items()
+            ))
+            writer.writerow((format(self.record_path), "", ""))
+            zinfo = ZipInfo(native(self.record_path), date_time=get_zipinfo_datetime())
+            zinfo.compress_type = self.compression
+            zinfo.external_attr = 0o664 << 16
+            self.writestr(zinfo, as_bytes(data.getvalue()))
+
+        ZipFile.close(self)

quarchpy/venv/Lib/site-packages/wheel-0.37.1.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

quarchpy/venv/Lib/site-packages/wheel-0.37.1.dist-info/LICENSE.txt

@@ -0,0 +1,22 @@
+"wheel" copyright (c) 2012-2014 Daniel Holth <dholth@fastmail.fm> and
+contributors.
+
+The MIT License
+
+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.

quarchpy/venv/Lib/site-packages/wheel-0.37.1.dist-info/METADATA

@@ -0,0 +1,69 @@
+Metadata-Version: 2.1
+Name: wheel
+Version: 0.37.1
+Summary: A built-package format for Python
+Home-page: https://github.com/pypa/wheel
+Author: Daniel Holth
+Author-email: dholth@fastmail.fm
+Maintainer: Alex Grönholm
+Maintainer-email: alex.gronholm@nextday.fi
+License: MIT
+Project-URL: Documentation, https://wheel.readthedocs.io/
+Project-URL: Changelog, https://wheel.readthedocs.io/en/stable/news.html
+Project-URL: Issue Tracker, https://github.com/pypa/wheel/issues
+Keywords: wheel,packaging
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: System :: Archiving :: Packaging
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Requires-Python: !=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,>=2.7
+Provides-Extra: test
+Requires-Dist: pytest (>=3.0.0) ; extra == 'test'
+Requires-Dist: pytest-cov ; extra == 'test'
+
+wheel
+=====
+
+This library is the reference implementation of the Python wheel packaging
+standard, as defined in `PEP 427`_.
+
+It has two different roles:
+
+#. A setuptools_ extension for building wheels that provides the
+   ``bdist_wheel`` setuptools command
+#. A command line tool for working with wheel files
+
+It should be noted that wheel is **not** intended to be used as a library, and
+as such there is no stable, public API.
+
+.. _PEP 427: https://www.python.org/dev/peps/pep-0427/
+.. _setuptools: https://pypi.org/project/setuptools/
+
+Documentation
+-------------
+
+The documentation_ can be found on Read The Docs.
+
+.. _documentation: https://wheel.readthedocs.io/
+
+Code of Conduct
+---------------
+
+Everyone interacting in the wheel project's codebases, issue trackers, chat
+rooms, and mailing lists is expected to follow the `PSF Code of Conduct`_.
+
+.. _PSF Code of Conduct: https://github.com/pypa/.github/blob/main/CODE_OF_CONDUCT.md
+
+
+

quarchpy/venv/Lib/site-packages/wheel-0.37.1.dist-info/RECORD

@@ -0,0 +1,49 @@
+wheel/__init__.py,sha256=yLOqsEZUPaM3VNKOMxQraLgCCyF8q3k10KY4C1Hi_Lo,23
+wheel/__main__.py,sha256=lF-YLO4hdQmoWuh4eWZd8YL1U95RSdm76sNLBXa0vjE,417
+wheel/bdist_wheel.py,sha256=2vfv3g_b8BvZ5Do9bpLEBdu9dQEcvoMQ1flXpKYFJDU,19075
+wheel/macosx_libfile.py,sha256=Xvp-IrFyRJ9RThIrPxfEpVCDGfljJPWRTZiyopk70hI,15930
+wheel/metadata.py,sha256=b3kPhZn2w2D9wengltX5nGIZQ3ERUOQ5U-K5vHKPdeg,4344
+wheel/pkginfo.py,sha256=GR76kupQzn1x9sKDaXuE6B6FsZ4OkfRtG7pndlXPvQ4,1257
+wheel/util.py,sha256=mnNZkJCi9DHLI_q4lTudoD0mW97h_AoAWl7prNPLXJc,938
+wheel/wheelfile.py,sha256=NyH8VcFLvu7jUwH6r4KoL_U45OKFVpUyJ5Z7gRAI_Lc,7574
+wheel/cli/__init__.py,sha256=GWSoGUpRabTf8bk3FsNTPrc5Fsr8YOv2dX55iY2W7eY,2572
+wheel/cli/convert.py,sha256=7F4vj23A2OghDDWn9gX2V-_TeXMza1a5nIejmFGEUJM,9498
+wheel/cli/pack.py,sha256=Bfq6KrHicZKrpbktkreeRxIaWwBozUP99JQy2D8-ddY,3364
+wheel/cli/unpack.py,sha256=0VWzT7U_xyenTPwEVavxqvdee93GPvAFHnR3Uu91aRc,673
+wheel/vendored/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wheel/vendored/packaging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wheel/vendored/packaging/_typing.py,sha256=x59EhQ57TMT-kTRyLZV25HZvYGGwbucTo6iKh_O0tMw,1812
+wheel/vendored/packaging/tags.py,sha256=noDvA--vVKVKlg49XMuZ5_Epi85jW7gMOKfiGuJ2sqU,29560
+wheel-0.37.1.dist-info/LICENSE.txt,sha256=zKniDGrx_Pv2lAjzd3aShsvuvN7TNhAMm0o_NfvmNeQ,1125
+wheel-0.37.1.dist-info/METADATA,sha256=YmebdXwPQlF98dp9V-Cy4BlE-M-fFM-J9cPVVvlSUi8,2328
+wheel-0.37.1.dist-info/WHEEL,sha256=z9j0xAa_JmUKMpmz72K0ZGALSM_n-wQVmGbleXx2VHg,110
+wheel-0.37.1.dist-info/entry_points.txt,sha256=N8HbYFST3yrNQYeB2wXWBEPUhFsEtKNRPaCFGJPyqyc,108
+wheel-0.37.1.dist-info/top_level.txt,sha256=HxSBIbgEstMPe4eFawhA66Mq-QYHMopXVoAncfjb_1c,6
+wheel-0.37.1.dist-info/RECORD,,
+wheel\__pycache__,,
+wheel-0.37.1.virtualenv,,
+wheel\__init__.cpython-27.pyc,,
+..\..\Scripts\wheel2.7.exe,,
+wheel\cli\unpack.cpython-27.pyc,,
+wheel\pkginfo.cpython-27.pyc,,
+wheel\vendored\packaging\tags.cpython-27.pyc,,
+wheel\macosx_libfile.cpython-27.pyc,,
+wheel\vendored\__pycache__,,
+wheel\bdist_wheel.cpython-27.pyc,,
+wheel\wheelfile.cpython-27.pyc,,
+wheel\vendored\packaging\__pycache__,,
+wheel\cli\__init__.cpython-27.pyc,,
+wheel\cli\convert.cpython-27.pyc,,
+wheel\__main__.cpython-27.pyc,,
+wheel\cli\pack.cpython-27.pyc,,
+wheel-0.37.1.dist-info\INSTALLER,,
+wheel\util.cpython-27.pyc,,
+..\..\Scripts\wheel.exe,,
+wheel\vendored\packaging\__init__.cpython-27.pyc,,
+wheel\cli\__pycache__,,
+..\..\Scripts\wheel2.exe,,
+wheel\metadata.cpython-27.pyc,,
+wheel\vendored\packaging\_typing.cpython-27.pyc,,
+wheel-0.37.1.dist-info\__pycache__,,
+..\..\Scripts\wheel-2.7.exe,,
+wheel\vendored\__init__.cpython-27.pyc,,

quarchpy/venv/Lib/site-packages/wheel-0.37.1.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+

quarchpy/venv/Lib/site-packages/wheel-0.37.1.dist-info/entry_points.txt

@@ -0,0 +1,6 @@
+[console_scripts]
+wheel = wheel.cli:main
+
+[distutils.commands]
+bdist_wheel = wheel.bdist_wheel:bdist_wheel
+

quarchpy/venv/Lib/site-packages/wheel-0.37.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+wheel

quarchpy/venv/Lib/site.py

@@ -0,0 +1,190 @@
+# -*- coding: utf-8 -*-
+"""
+A simple shim module to fix up things on Python 2 only.
+
+Note: until we setup correctly the paths we can only import built-ins.
+"""
+import sys
+
+
+def main():
+    """Patch what needed, and invoke the original site.py"""
+    here = __file__  # the distutils.install patterns will be injected relative to this site.py, save it here
+    config = read_pyvenv()
+    sys.real_prefix = sys.base_prefix = config["base-prefix"]
+    sys.base_exec_prefix = config["base-exec-prefix"]
+    sys.base_executable = config["base-executable"]
+    global_site_package_enabled = config.get("include-system-site-packages", False) == "true"
+    rewrite_standard_library_sys_path()
+    disable_user_site_package()
+    load_host_site(here)
+    if global_site_package_enabled:
+        add_global_site_package()
+    rewrite_getsitepackages(here)
+
+
+def load_host_site(here):
+    """trigger reload of site.py - now it will use the standard library instance that will take care of init"""
+    # we have a duality here, we generate the platform and pure library path based on what distutils.install specifies
+    # because this is what pip will be using; the host site.py though may contain it's own pattern for where the
+    # platform and pure library paths should exist
+
+    # notably on Ubuntu there's a patch for getsitepackages to point to
+    # - prefix + local/lib/pythonx.y/dist-packages
+    # - prefix + lib/pythonx.y/dist-packages
+    # while distutils.install.cmd still points both of these to
+    # - prefix + lib/python2.7/site-packages
+
+    # to facilitate when the two match, or not we first reload the site.py, now triggering the import of host site.py,
+    # as this will ensure that initialization code within host site.py runs
+
+    reload(sys.modules["site"])  # noqa # call system site.py to setup import libraries
+
+    # and then if the distutils site packages are not on the sys.path we add them via add_site_dir; note we must add
+    # them by invoking add_site_dir to trigger the processing of pth files
+
+    add_site_dir = sys.modules["site"].addsitedir
+    for path in get_site_packages_dirs(here):
+        add_site_dir(path)
+
+
+def get_site_packages_dirs(here):
+    import json
+    import os
+
+    site_packages = r"""
+    ["..\\site-packages"]
+    """
+
+    for path in json.loads(site_packages):
+        yield os.path.abspath(os.path.join(here, path.encode("utf-8")))
+
+
+sep = "\\" if sys.platform == "win32" else "/"  # no os module here yet - poor mans version
+
+
+def read_pyvenv():
+    """read pyvenv.cfg"""
+    config_file = "{}{}pyvenv.cfg".format(sys.prefix, sep)
+    with open(config_file) as file_handler:
+        lines = file_handler.readlines()
+    config = {}
+    for line in lines:
+        try:
+            split_at = line.index("=")
+        except ValueError:
+            continue  # ignore bad/empty lines
+        else:
+            config[line[:split_at].strip()] = line[split_at + 1 :].strip()
+    return config
+
+
+def rewrite_standard_library_sys_path():
+    """Once this site file is loaded the standard library paths have already been set, fix them up"""
+    exe, prefix, exec_prefix = get_exe_prefixes(base=False)
+    base_exe, base_prefix, base_exec = get_exe_prefixes(base=True)
+    exe_dir = exe[: exe.rfind(sep)]
+    for at, path in enumerate(sys.path):
+        path = abs_path(path)  # replace old sys prefix path starts with new
+        skip_rewrite = path == exe_dir  # don't fix the current executable location, notably on Windows this gets added
+        skip_rewrite = skip_rewrite  
+        if not skip_rewrite:
+            sys.path[at] = map_path(path, base_exe, exe_dir, exec_prefix, base_prefix, prefix, base_exec)
+
+    # the rewrite above may have changed elements from PYTHONPATH, revert these if on
+    if sys.flags.ignore_environment:
+        return
+    import os
+
+    python_paths = []
+    if "PYTHONPATH" in os.environ and os.environ["PYTHONPATH"]:
+        for path in os.environ["PYTHONPATH"].split(os.pathsep):
+            if path not in python_paths:
+                python_paths.append(path)
+    sys.path[: len(python_paths)] = python_paths
+
+
+def get_exe_prefixes(base=False):
+    return tuple(abs_path(getattr(sys, ("base_" if base else "") + i)) for i in ("executable", "prefix", "exec_prefix"))
+
+
+def abs_path(value):
+    values, keep = value.split(sep), []
+    at = len(values) - 1
+    while at >= 0:
+        if values[at] == "..":
+            at -= 1
+        else:
+            keep.append(values[at])
+        at -= 1
+    return sep.join(keep[::-1])
+
+
+def map_path(path, base_executable, exe_dir, exec_prefix, base_prefix, prefix, base_exec_prefix):
+    if path_starts_with(path, exe_dir):
+        # content inside the exe folder needs to remap to original executables folder
+        orig_exe_folder = base_executable[: base_executable.rfind(sep)]
+        return "{}{}".format(orig_exe_folder, path[len(exe_dir) :])
+    elif path_starts_with(path, prefix):
+        return "{}{}".format(base_prefix, path[len(prefix) :])
+    elif path_starts_with(path, exec_prefix):
+        return "{}{}".format(base_exec_prefix, path[len(exec_prefix) :])
+    return path
+
+
+def path_starts_with(directory, value):
+    return directory.startswith(value if value[-1] == sep else value + sep)
+
+
+def disable_user_site_package():
+    """Flip the switch on enable user site package"""
+    # sys.flags is a c-extension type, so we cannot monkeypatch it, replace it with a python class to flip it
+    sys.original_flags = sys.flags
+
+    class Flags(object):
+        def __init__(self):
+            self.__dict__ = {key: getattr(sys.flags, key) for key in dir(sys.flags) if not key.startswith("_")}
+
+    sys.flags = Flags()
+    sys.flags.no_user_site = 1
+
+
+def add_global_site_package():
+    """add the global site package"""
+    import site
+
+    # add user site package
+    sys.flags = sys.original_flags  # restore original
+    site.ENABLE_USER_SITE = None  # reset user site check
+    # add the global site package to the path - use new prefix and delegate to site.py
+    orig_prefixes = None
+    try:
+        orig_prefixes = site.PREFIXES
+        site.PREFIXES = [sys.base_prefix, sys.base_exec_prefix]
+        site.main()
+    finally:
+        site.PREFIXES = orig_prefixes + site.PREFIXES
+
+
+# Debian and it's derivatives patch this function. We undo the damage
+def rewrite_getsitepackages(here):
+    site = sys.modules["site"]
+
+    site_package_dirs = get_site_packages_dirs(here)
+    orig_getsitepackages = site.getsitepackages
+
+    def getsitepackages():
+        sitepackages = orig_getsitepackages()
+        if sys.prefix not in site.PREFIXES or sys.exec_prefix not in site.PREFIXES:
+            # Someone messed with the prefixes, so we stop patching
+            return sitepackages
+        for path in site_package_dirs:
+            if path not in sitepackages:
+                sitepackages.insert(0, path)
+
+        return sitepackages
+
+    site.getsitepackages = getsitepackages
+
+
+main()

quarchpy/venv/Scripts/activate

@@ -0,0 +1,83 @@
+# This file must be used with "source bin/activate" *from bash*
+# you cannot run it directly
+
+
+if [ "${BASH_SOURCE-}" = "$0" ]; then
+    echo "You must source this script: \$ source $0" >&2
+    exit 33
+fi
+
+deactivate () {
+    unset -f pydoc >/dev/null 2>&1 || true
+
+    # reset old environment variables
+    # ! [ -z ${VAR+_} ] returns true if VAR is declared at all
+    if ! [ -z "${_OLD_VIRTUAL_PATH:+_}" ] ; then
+        PATH="$_OLD_VIRTUAL_PATH"
+        export PATH
+        unset _OLD_VIRTUAL_PATH
+    fi
+    if ! [ -z "${_OLD_VIRTUAL_PYTHONHOME+_}" ] ; then
+        PYTHONHOME="$_OLD_VIRTUAL_PYTHONHOME"
+        export PYTHONHOME
+        unset _OLD_VIRTUAL_PYTHONHOME
+    fi
+
+    # The hash command must be called to get it to forget past
+    # commands. Without forgetting past commands the $PATH changes
+    # we made may not be respected
+    hash -r 2>/dev/null
+
+    if ! [ -z "${_OLD_VIRTUAL_PS1+_}" ] ; then
+        PS1="$_OLD_VIRTUAL_PS1"
+        export PS1
+        unset _OLD_VIRTUAL_PS1
+    fi
+
+    unset VIRTUAL_ENV
+    if [ ! "${1-}" = "nondestructive" ] ; then
+    # Self destruct!
+        unset -f deactivate
+    fi
+}
+
+# unset irrelevant variables
+deactivate nondestructive
+
+VIRTUAL_ENV='C:\Projects\Software\Python\QuarchPy\Trunk\quarchpy\venv'
+if ([ "$OSTYPE" = "cygwin" ] || [ "$OSTYPE" = "msys" ]) && $(command -v cygpath &> /dev/null) ; then
+    VIRTUAL_ENV=$(cygpath -u "$VIRTUAL_ENV")
+fi
+export VIRTUAL_ENV
+
+_OLD_VIRTUAL_PATH="$PATH"
+PATH="$VIRTUAL_ENV/Scripts:$PATH"
+export PATH
+
+# unset PYTHONHOME if set
+if ! [ -z "${PYTHONHOME+_}" ] ; then
+    _OLD_VIRTUAL_PYTHONHOME="$PYTHONHOME"
+    unset PYTHONHOME
+fi
+
+if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT-}" ] ; then
+    _OLD_VIRTUAL_PS1="${PS1-}"
+    if [ "x" != x ] ; then
+        PS1="() ${PS1-}"
+    else
+        PS1="(`basename \"$VIRTUAL_ENV\"`) ${PS1-}"
+    fi
+    export PS1
+fi
+
+# Make sure to unalias pydoc if it's already there
+alias pydoc 2>/dev/null >/dev/null && unalias pydoc || true
+
+pydoc () {
+    python -m pydoc "$@"
+}
+
+# The hash command must be called to get it to forget past
+# commands. Without forgetting past commands the $PATH changes
+# we made may not be respected
+hash -r 2>/dev/null

quarchpy/venv/Scripts/activate.bat

@@ -0,0 +1,39 @@
+@echo off
+
+set "VIRTUAL_ENV=C:\Projects\Software\Python\QuarchPy\Trunk\quarchpy\venv"
+
+if defined _OLD_VIRTUAL_PROMPT (
+    set "PROMPT=%_OLD_VIRTUAL_PROMPT%"
+) else (
+    if not defined PROMPT (
+        set "PROMPT=$P$G"
+    )
+    if not defined VIRTUAL_ENV_DISABLE_PROMPT (
+        set "_OLD_VIRTUAL_PROMPT=%PROMPT%"
+    )
+)
+if not defined VIRTUAL_ENV_DISABLE_PROMPT (
+    if "" NEQ "" (
+        set "PROMPT=() %PROMPT%"
+    ) else (
+        for %%d in ("%VIRTUAL_ENV%") do set "PROMPT=(%%~nxd) %PROMPT%"
+    )
+)
+
+REM Don't use () to avoid problems with them in %PATH%
+if defined _OLD_VIRTUAL_PYTHONHOME goto ENDIFVHOME
+    set "_OLD_VIRTUAL_PYTHONHOME=%PYTHONHOME%"
+:ENDIFVHOME
+
+set PYTHONHOME=
+
+REM if defined _OLD_VIRTUAL_PATH (
+if not defined _OLD_VIRTUAL_PATH goto ENDIFVPATH1
+    set "PATH=%_OLD_VIRTUAL_PATH%"
+:ENDIFVPATH1
+REM ) else (
+if defined _OLD_VIRTUAL_PATH goto ENDIFVPATH2
+    set "_OLD_VIRTUAL_PATH=%PATH%"
+:ENDIFVPATH2
+
+set "PATH=%VIRTUAL_ENV%\Scripts;%PATH%"