PyProd 0.1.0__py3-none-any.whl

pyprod/__main__.py

@@ -0,0 +1,4 @@
+from .main import main
+
+if __name__ == "__main__":
+    main()

pyprod/main.py

@@ -0,0 +1,118 @@
+import argparse
+import asyncio
+import logging
+import os
+import sys
+from pathlib import Path
+
+import pyprod
+import pyprod.prod
+
+logger = logging.getLogger(__name__)
+
+parser = argparse.ArgumentParser(
+    description="""PyProd - More makable than make""",
+)
+
+parser.add_argument(
+    "-f", "--file", help="Use FILE as the Prodfile (default: 'PRODFILE.py')"
+)
+
+parser.add_argument(
+    "-j",
+    "--job",
+    type=int,
+    default=1,
+    help="Allow up to N jobs to run simultaneously (default: 1)",
+)
+
+parser.add_argument(
+    "-C",
+    "--directory",
+    dest="directory",
+    help="Change to DIRECTORY before performing any operations",
+)
+
+parser.add_argument(
+    "-v",
+    dest="verbose",
+    action="count",
+    default=0,
+    help="Increase verbosity level (default: 0)",
+)
+
+
+parser.add_argument("targets", nargs="*", help="Build targets")
+
+
+def print_exc(e):
+    match pyprod.args.verbose:
+        case 0:
+            logger.error("%s: %s", type(e).__name__, e)
+        case 1:
+            logger.error("%r", e)
+        case _:
+            logger.exception("Terminated by exception")
+
+
+def main():
+    args = pyprod.args = parser.parse_args()
+    pyprod.verbose = args.verbose
+    chdir = args.directory
+    if chdir:
+        os.chdir(chdir)
+
+    if "" not in sys.path:
+        sys.path.insert(0, "")
+
+    match args.verbose:
+        case 0:
+            level = logging.ERROR
+        case 1:
+            level = logging.INFO
+        case _:
+            level = logging.DEBUG
+
+    logging.basicConfig(level=level, format="%(asctime)s: %(message)s")
+
+    if args.file:
+        pyprodfiles = [args.file]
+    else:
+        pyprodfiles = ["Prodfile.py"]
+
+    for mod in pyprodfiles:
+        mod = pyprod.modulefile = Path(mod)
+        if mod.is_file():
+            break
+    else:
+        sys.exit("No make module found")
+
+    params = {}
+    targets = []
+    for target in args.targets:
+        if "=" in target:
+            name, value = target.split("=", 1)
+            params[name] = value
+        else:
+            targets.append(target)
+
+    try:
+        # load module
+        prod = pyprod.prod.Prod(mod, args.job, params)
+
+        # select targets
+        if not targets:
+            target = prod.get_default_target()
+            if not target:
+                sys.exit("No default target")
+            targets = [target]
+
+        ret = asyncio.run(prod.start(targets))
+        if not ret:
+            print(f"Nothing to be done for {targets}")
+
+    except pyprod.prod.HandledExceptionError:
+        # ignored
+        pass
+    except Exception as e:
+        print_exc(e)

pyprod/prod.py

@@ -0,0 +1,532 @@
+import asyncio
+import concurrent.futures
+import datetime
+import importlib
+import importlib.machinery
+import logging
+import os
+import re
+import shlex
+import shutil
+import subprocess
+import sys
+from collections import defaultdict
+from collections.abc import Collection
+from dataclasses import dataclass, field
+from fnmatch import fnmatch, translate
+from pathlib import Path
+
+import pyprod
+
+from .utils import flatten, unique_list
+from .venv import pip
+
+logger = logging.getLogger(__name__)
+
+
+class CircularReferenceError(Exception):
+    pass
+
+
+class NoRuleToMakeTargetError(Exception):
+    pass
+
+
+class InvalidRuleError(Exception):
+    pass
+
+
+class HandledExceptionError(Exception):
+    pass
+
+
+omit = object()
+
+
+def run(
+    *args,
+    echo=True,
+    shell=None,
+    stdout=False,
+    cwd=None,
+    text=True,
+    check=True,
+):
+    match args:
+        case [[*tokens]]:
+            if shell is None:
+                shell = False
+            args = [list(str(t) for t in flatten(tokens))]
+            sargs = str(tokens)
+        case _:
+            args = [" ".join(str(a) for a in flatten(args))]
+            sargs = args[0]
+            if shell is None:
+                shell = True
+
+    if stdout is True:
+        stdout = subprocess.PIPE
+    elif stdout is False:
+        stdout = None
+
+    if echo:
+        print("run: %s" % sargs, file=sys.stderr)
+    try:
+        ret = subprocess.run(
+            *args, cwd=cwd, shell=shell, stdout=stdout, text=text, check=check
+        )
+    except subprocess.CalledProcessError as e:
+        match pyprod.verbose:
+            case 0:
+                logger.debug("command failed: %s %s", str(e), sargs)
+            case _:
+                logger.warning("command failed: %s %s", str(e), sargs)
+
+        raise HandledExceptionError() from e
+
+    return ret
+
+
+def capture(*args, echo=True, cwd=None, check=True, text=True, shell=None):
+    ret = run(
+        *args, echo=echo, cwd=cwd, check=check, text=text, stdout=True, shell=shell
+    )
+    ret = ret.stdout or ""
+    ret = ret.rstrip("\n")
+    return ret
+
+
+def glob(path, dir="."):
+    ret = []
+    for c in Path(dir).glob(path):
+        # ignore dot files
+        if any(p.startswith(".") for p in c.parts):
+            continue
+        ret.append(c)
+    return ret
+
+
+def rule_to_re(rule):
+    if not isinstance(rule, (str, Path)):
+        raise InvalidRuleError(rule)
+
+    srule = str(rule)
+    srule = translate(srule)
+    srule = replace_pattern(srule, "(?P<stem>.*)", maxreplace=1)
+    if isinstance(rule, Path):
+        return Path(srule)
+    return srule
+
+
+def replace_pattern(rule, replaceto, *, maxreplace=None):
+    n = 0
+    s_rule = str(rule)
+
+    def f(m):
+        nonlocal n
+        if len(m[0]) == 2:
+            return "%"
+        else:
+            n += 1
+            if maxreplace is not None:
+                if n > maxreplace:
+                    # contains multiple '%'
+                    raise InvalidRuleError(s_rule)
+            return replaceto
+
+    s_rule = re.sub("%%|%", f, s_rule)
+    if isinstance(rule, Path):
+        return Path(s_rule)
+    return s_rule
+
+
+@dataclass
+class Rule:
+    targets: list
+    pattern: str | None
+    depends: list
+    uses: list | None
+    builder: str | None
+
+    orig_targets: list = field(init=False)
+    orig_depends: list = field(init=False)
+    orig_uses: list = field(init=False)
+
+    def __post_init__(self):
+        self.orig_targets = self.targets
+        self.orig_depends = self.depends
+        self.orig_uses = self.uses
+
+        self.targets = [rule_to_re(r) for r in flatten(self.targets)]
+        self.depends = list(flatten(self.depends))
+        if self.pattern:
+            self.pattern = rule_to_re(self.pattern)
+        if self.uses:
+            self.uses = list(flatten(self.uses))
+
+    def __call__(self, f):
+        self.builder = f
+        return f
+
+
+class Rules:
+    def __init__(self):
+        self.rules = []
+        self.tree = defaultdict(set)
+        self._detect_loop = set()
+        self.frozen = False
+
+    def add_rule(self, targets, pattern, depends, uses, builder):
+        if self.frozen:
+            raise RuntimeError("No new rule can be added after initialization")
+
+        dep = Rule(
+            targets,
+            pattern,
+            depends,
+            uses,
+            builder,
+        )
+        self.rules.append(dep)
+        return dep
+
+    def rule(self, target, pattern=None, depends=(), uses=()):
+        if (not isinstance(depends, Collection)) or isinstance(depends, str):
+            depends = [depends]
+        if (not isinstance(uses, Collection)) or isinstance(uses, str):
+            uses = [uses]
+        dep = self.add_rule([target], pattern, depends, uses, None)
+        return dep
+
+    def iter_rule(self, name):
+        name = str(name)
+        for dep in self.rules:
+            for target in dep.targets:
+                m = re.fullmatch(str(target), name)
+                if m:
+                    stem = None
+                    d = m.groupdict().get("stem", None)
+                    if d is not None:
+                        stem = d
+                    elif dep.pattern:
+                        m = re.fullmatch(str(dep.pattern), name)
+                        d = m.groupdict().get("stem", None)
+                        if d is not None:
+                            stem = d
+
+                    depends = [replace_pattern(r, stem) for r in dep.depends]
+                    uses = [replace_pattern(r, stem) for r in dep.uses]
+
+                    yield depends, uses, dep
+                    break
+
+    def get_dep_names(self, name):
+        assert name
+        ret_depends = []
+        ret_uses = []
+
+        for depends, uses, dep in self.iter_rule(name):
+            if dep.builder:
+                continue
+
+            ret_depends.extend(depends)
+            ret_uses.extend(uses)
+
+        return unique_list(ret_depends), unique_list(ret_uses)
+
+    def select_first_target(self):
+        for dep in self.rules:
+            for target in dep.orig_targets:
+                s_target = str(target)
+                # pattern?
+                matches = re.finditer(r"%%|%", s_target)
+                if any((len(m[0]) == 1) for m in matches):
+                    # has %
+                    continue
+                return target
+
+    def select_builder(self, name):
+        for depends, uses, dep in self.iter_rule(name):
+            if not dep.builder:
+                continue
+            return depends, uses, dep
+
+    def build_tree(self, name, lv=1):
+        self.frozen = True
+
+        name = str(name)
+        if name in self._detect_loop:
+            raise CircularReferenceError(name)
+        self._detect_loop.add(name)
+        try:
+            if name in self.tree:
+                return
+            deps, uses = self.get_dep_names(name)
+            depends = deps + uses
+
+            selected = self.select_builder(name)
+            if selected:
+                build_deps, build_uses, _ = selected
+                depends.extend(build_deps)
+                depends.extend(build_uses)
+
+            depends = unique_list(depends)
+            self.tree[name].update(str(d) for d in depends)
+            for dep in depends:
+                self.build_tree(dep, lv=lv + 1)
+
+        finally:
+            self._detect_loop.remove(name)
+
+
+class Checkers:
+    def __init__(self):
+        self.checkers = []
+
+    def get_checker(self, name):
+        for targets, f in self.checkers:
+            for target in targets:
+                if fnmatch(name, str(target)):
+                    return f
+
+    def add_check(self, target, f):
+        self.checkers.append((list(t for t in flatten(target)), f))
+
+    def check(self, target):
+        def deco(f):
+            self.add_check(target, f)
+            return f
+
+        return deco
+
+
+MAX_TS = 1 << 63
+
+
+def is_file_exists(name):
+    return os.path.getmtime(name)
+
+
+class Exists:
+    def __init__(self, name, exists, ts=None):
+        self.name = name
+        self.exists = exists
+        self.ts = ts if exists else 0
+
+    def __repr__(self):
+        return f"Exists({self.name!r}, {self.exists!r}, {self.ts!r})"
+
+
+class Params:
+    def __init__(self, params):
+        if params:
+            self.__dict__.update(params)
+
+    def __getattr__(self, name):
+        # never raise AttributeError
+        return ""
+
+    def get(self, name, default=None):
+        # hasattr cannot be used since __getattr__ never raise AttributeError
+        if name in self.__dict__:
+            return getattr(self, name)
+        else:
+            return default
+
+
+class Envs:
+    def __getattr__(self, name):
+        return os.environ.get(name, "")
+
+    def __setattr__(self, name, value):
+        os.environ[name] = str(value)
+
+    def __getitem__(self, name):
+        return os.environ.get(name, "")
+
+    def __setitem__(self, name, value):
+        os.environ[name] = str(value)
+
+    def __delitem__(self, name):
+        if name in os.environ:
+            del os.environ[name]
+
+    def get(self, name, default=None):
+        return os.environ.get(name, default=default)
+
+
+class Prod:
+    def __init__(self, modulefile, njobs=1, params=None):
+        self.modulefile = Path(modulefile)
+        self.rules = Rules()
+        self.checkers = Checkers()
+        if njobs > 1:
+            self.executor = concurrent.futures.ThreadPoolExecutor(max_workers=njobs)
+        else:
+            self.executor = None
+        self.params = Params(params)
+        self.buildings = {}
+        self.module = self.load_pyprodfile(self.modulefile)
+        self.built = 0  # number of build execused
+
+    def get_module_globals(self):
+        globals = {
+            "pip": pip,
+            "rule": self.rules.rule,
+            "check": self.checkers.check,
+            "Path": Path,
+            "run": run,
+            "capture": capture,
+            "glob": glob,
+            "MAX_TS": MAX_TS,
+            "environ": Envs(),
+            "shutil": shutil,
+            "quote": shlex.quote,
+            "params": self.params,
+        }
+        return globals
+
+    def load_pyprodfile(self, pyprodfile: Path) -> dict:
+        spath = os.fspath(pyprodfile)
+        loader = importlib.machinery.SourceFileLoader(pyprodfile.stem, spath)
+        spec = importlib.util.spec_from_file_location(
+            pyprodfile.stem, spath, loader=loader
+        )
+        mod = importlib.util.module_from_spec(spec)
+
+        # exec module
+        mod.__dict__.update(self.get_module_globals())
+
+        spec.loader.exec_module(mod)
+        return mod
+
+    async def run_in_executor(self, func, *args, **kwargs):
+        if self.executor:
+            loop = asyncio.get_running_loop()
+            return await loop.run_in_executor(
+                self.executor, lambda: func(*args, **kwargs)
+            )
+        else:
+            return func(*args, **kwargs)
+
+    def get_default_target(self):
+        return self.rules.select_first_target()
+
+    async def start(self, deps):
+        self.built = 0
+        names = []
+        for name in deps:
+            if isinstance(name, str):
+                value = getattr(self.module, name, None)
+                if value:
+                    names.append(value)
+                else:
+                    names.append(name)
+            else:
+                names.append(name)
+
+        builds = []
+        waitings = []
+        for obj in flatten(names):
+            if isinstance(obj, str | Path):
+                builds.append(obj)
+            elif isinstance(obj, Rule):
+                raise InvalidRuleError(obj)
+            elif callable(obj):
+                self.built += 1
+                task = asyncio.create_task(self.run_in_executor(obj))
+                waitings.append(task)
+            else:
+                raise InvalidRuleError(obj)
+
+        await self.build(builds)
+        await asyncio.gather(*waitings)
+        return self.built
+
+    async def build(self, deps):
+        tasks = []
+        waits = []
+        for dep in deps:
+            if dep not in self.buildings:
+                ev = asyncio.Event()
+                self.buildings[dep] = ev
+                task = self.run(dep)
+                tasks.append((dep, task))
+                waits.append(ev)
+            else:
+                obj = self.buildings[dep]
+                if isinstance(obj, asyncio.Event):
+                    waits.append(obj)
+
+        for dep, task in tasks:
+            ev = self.buildings[dep]
+            try:
+                self.buildings[dep] = await task
+            finally:
+                ev.set()
+
+        events = [ev.wait() for ev in waits]
+        await asyncio.gather(*events)
+
+        ts = []
+        for dep in deps:
+            obj = self.buildings[dep]
+            if isinstance(obj, int | float):
+                ts.append(obj)
+        if ts:
+            return max(ts)
+        return 0
+
+    async def is_exists(self, name):
+        checker = self.checkers.get_checker(name)
+        try:
+            if checker:
+                ret = await self.run_in_executor(checker, name)
+            else:
+                ret = await self.run_in_executor(is_file_exists, name)
+        except FileNotFoundError:
+            ret = False
+
+        if not ret:
+            return Exists(name, False)
+        if isinstance(ret, datetime.datetime):
+            ret = ret.timestamp()
+        if ret < 0:
+            ret = MAX_TS
+        return Exists(name, True, ret)
+
+    async def run(self, name):  # -> Any | int:
+        s_name = str(name)
+
+        self.rules.build_tree(s_name)
+        deps, uses = self.rules.get_dep_names(s_name)
+        selected = self.rules.select_builder(s_name)
+        if selected:
+            build_deps, build_uses, builder = selected
+            deps = deps + build_deps
+            uses = uses + build_uses
+
+        ts = 0
+        if deps:
+            ts = await self.build(deps)
+        if uses:
+            await self.build(uses)
+
+        exists = await self.is_exists(s_name)
+
+        if not exists.exists:
+            logger.debug("%r does not exists", str(s_name))
+        elif (ts >= MAX_TS) or (exists.ts < ts):
+            logger.debug("%r should be updated", str(s_name))
+        else:
+            logger.debug("%r already exists", str(s_name))
+
+        if not exists.exists and not selected:
+            raise NoRuleToMakeTargetError(s_name)
+        elif selected and ((not exists.exists) or (ts >= MAX_TS) or (exists.ts < ts)):
+            logger.warning("building: %r", s_name)
+            await self.run_in_executor(builder.builder, name, *build_deps)
+            self.built += 1
+            return MAX_TS
+
+        return max(ts, exists.ts)

pyprod/utils.py

@@ -0,0 +1,17 @@
+from collections.abc import Iterable, Sequence
+
+
+def flatten(seq):
+    if isinstance(seq, str) or (not isinstance(seq, Sequence)):
+        yield seq
+        return
+
+    for item in seq:
+        if isinstance(item, str) or (not isinstance(item, Iterable)):
+            yield item
+        else:
+            yield from flatten(item)
+
+
+def unique_list(lst):
+    return list({e: None for e in lst}.keys())

pyprod/venv.py

@@ -0,0 +1,47 @@
+import os
+import subprocess
+import sys
+import sysconfig
+import threading
+import venv
+from pathlib import Path
+
+import pyprod
+
+from .utils import flatten
+
+THREADID = threading.get_ident()
+pyprodenv = ".pyprod"
+venvdir = None
+
+PYPRODVENV = ".pyprod"
+
+
+def makevenv(conffile):
+    global venvdir
+    venvdir = Path(".") / f".{conffile.name}{PYPRODVENV}"
+    if not venvdir.is_dir():
+        venv.main([str(venvdir)])
+
+    purelib = sysconfig.get_path(
+        "purelib", scheme="venv", vars={"base": str(venvdir.resolve())}
+    )
+    sys.path.insert(0, purelib)
+
+    os.environ["VIRTUAL_ENV"] = str(venvdir)
+    os.environ["PATH"] = os.path.pathsep.join(
+        [str(venvdir / "bin"), os.environ["PATH"]]
+    )
+
+
+def pip(*args):
+    if THREADID != threading.get_ident():
+        raise RuntimeError("pip() should not be called in workder thread")
+
+    if not venvdir:
+        makevenv(pyprod.modulefile)
+    args = flatten(args)
+    subprocess.run(
+        [venvdir / "bin/python", "-m", "pip", "--no-input", "install", *args],
+        check=True,
+    )

pyprod-0.1.0.dist-info/METADATA

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: PyProd
+Version: 0.1.0
+Summary: PyProd: More Makeable than Make
+Project-URL: Homepage, https://github.com/atsuoishimoto/pyprod
+Project-URL: Documentation, https://pyprod.readthedocs.io/en/latest/
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.10
+Description-Content-Type: text/x-rst
+
+PyProd - More Makeable than Make
+=================================
+
+PyProd is a Python script that can be used as an alternative to Makefile. By leveraging Python's versatility, it enables you to define build rules and dependencies programmatically, allowing for dynamic configurations, integration with existing Python libraries, and custom build logic not easily achievable with traditional Makefiles. For detailed documentation, please refer to the `official documentation <https://example.com/pyprod-docs>`_.
+
+
+Features
+--------
+
+- Define build rules in Python: Use Python functions to create clear and concise build logic.
+- Specify dependencies for each rule: Automatically track and resolve dependencies between files, such as source files and headers.
+- Easily extendable with custom Python functions: Integrate custom logic for specialized tasks, like code linting or deployment.
+- Manages virtual environments: Automatically create and manage virtual environments for each project, ensuring a clean and isolated build environment.
+
+Installation
+--------------
+
+To install PyProd, simply use pip:
+
+.. code-block:: sh
+
+    pip install pyprod
+
+Usage
+-----
+
+In PyProd, a traditional Makefile for C can be expressed as a Python script like this:
+
+
+.. code-block:: python
+
+    CC = "gcc"
+    CFLAGS = "-I."
+    DEPS = "hello.h"
+    OBJS = "hello.o main.o".split()
+
+    @rule("%.o", depends=("%.c", DEPS))
+    def compile(target, src, *deps):
+        run(CC, "-c -o", target, src, CFLAGS)
+
+    @rule("hello.exe", depends=OBJS)
+    def link(target, *objs):
+        run(CC, "-o", target, objs)
+
+    def clean():
+        run("rm -f", OBJS, "hello.exe")
+
+    all = "hello.exe"
+
+To run the build script, simply execute:
+
+.. code-block:: sh
+
+    $ cd project
+    $ pyprod
+
+License
+-------
+
+PyProd is licensed under the MIT License. See the `LICENSE <LICENSE>`_ file for more details.

pyprod-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+pyprod/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyprod/__main__.py,sha256=Vdhw8YA1K3wPMlbJQYL5WqvRzAKVeZ16mZQFO9VRmCo,62
+pyprod/main.py,sha256=nS0mcLy3Ix7ydnX1Pu5g7ceLzhh6DndwJWO5sjO_qWg,2580
+pyprod/prod.py,sha256=pVNAc_piwsMo0KaML9AChrm_TnXIeZK_cMT6MZ7abWo,14564
+pyprod/utils.py,sha256=oiiUkSbeqTazbtJ6gz7ZKqG1OvAeV-nV9u_3Y0DCOOM,401
+pyprod/venv.py,sha256=_riw56YQvUOSd55u_1m9ElsqPdjM5qVvIZP6dr9Fzt4,1051
+pyprod-0.1.0.dist-info/METADATA,sha256=KfxGRpJW-_Vjs5O-r9IGOTjdTm29K4R8_eh-8TVMf98,2470
+pyprod-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pyprod-0.1.0.dist-info/entry_points.txt,sha256=zFycf8BYSMRDTiI0jftmcvtkf9XM4MZ4BL3JaIer_ZM,44
+pyprod-0.1.0.dist-info/licenses/LICENSE,sha256=OtPgwnlLrsVEYPnTraun5AqftAT5vUv4rIan-qYj7nE,1071
+pyprod-0.1.0.dist-info/RECORD,,

pyprod-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pyprod-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pyprod = pyprod.main:main

pyprod-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Atsuo Ishimoto
+
+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.