PyProd 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

pyprod/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.5.0"

pyprod/main.py

@@ -15,7 +15,14 @@ parser = argparse.ArgumentParser(
 )
 
 parser.add_argument(
-    "-f", "--file", help="Use FILE as the Prodfile (default: 'PRODFILE.py')"
+    "-C",
+    "--directory",
+    dest="directory",
+    help="Change to DIRECTORY before performing any operations",
+)
+
+parser.add_argument(
+    "-f", "--file", help="Use FILE as the Prodfile (default: 'Prodfile.py')"
 )
 
 parser.add_argument(
@@ -27,10 +34,15 @@ parser.add_argument(
 )
 
 parser.add_argument(
-    "-C",
-    "--directory",
-    dest="directory",
-    help="Change to DIRECTORY before performing any operations",
+    "-r", "--rebuild", dest="rebuild", action="store_true", help="Rebuild all"
+)
+
+parser.add_argument(
+    "-g",
+    "--use-git",
+    dest="use_git",
+    action="store_true",
+    help="Get file timestamps from Git",
 )
 
 parser.add_argument(
@@ -55,8 +67,13 @@ def print_exc(e):
             logger.exception("Terminated by exception")
 
 
+def init_args(args=None):
+    args = pyprod.args = parser.parse_args(args)
+    return args
+
+
 def main():
-    args = pyprod.args = parser.parse_args()
+    args = init_args()
     pyprod.verbose = args.verbose
     chdir = args.directory
     if chdir:
@@ -89,6 +106,7 @@ def main():
 
     params = {}
     targets = []
+
     for target in args.targets:
         if "=" in target:
             name, value = target.split("=", 1)
@@ -99,7 +117,6 @@ def main():
     try:
         # load module
         prod = pyprod.prod.Prod(mod, args.job, params)
-
         # select targets
         if not targets:
             target = prod.get_default_target()
@@ -107,7 +124,10 @@ def main():
                 sys.exit("No default target")
             targets = [target]
 
-        ret = asyncio.run(prod.start(targets))
+        ret = 0
+        for target in targets:
+            ret += asyncio.run(prod.start([target]))
+
         if not ret:
             print(f"Nothing to be done for {targets}")
 

pyprod/prod.py

@@ -15,8 +15,9 @@ from collections import defaultdict
 from collections.abc import Collection
 from dataclasses import dataclass, field
 from fnmatch import fnmatch, translate
+from functools import wraps
 from pathlib import Path
-
+import dateutil.parser
 import pyprod
 
 from .utils import flatten, unique_list
@@ -37,6 +38,10 @@ class RuleError(Exception):
     pass
 
 
+class TargetError(Exception):
+    pass
+
+
 class HandledExceptionError(Exception):
     pass
 
@@ -99,9 +104,10 @@ def capture(*args, echo=True, cwd=None, check=True, text=True, shell=None):
 
 def glob(path, dir="."):
     ret = []
-    for c in Path(dir).glob(path):
+    root = Path(dir)
+    for c in root.glob(path):
         # ignore dot files
-        if any(p.startswith(".") for p in c.parts):
+        if any((p not in (".", "..")) and p.startswith(".") for p in c.parts):
             continue
         ret.append(c)
     return ret
@@ -109,7 +115,7 @@ def glob(path, dir="."):
 
 def rule_to_re(rule):
     if not isinstance(rule, (str, Path)):
-        raise RuleError(rule)
+        raise TypeError(f"str or Path required: {rule}")
 
     srule = str(rule)
     srule = translate(srule)
@@ -156,47 +162,51 @@ def _check_pattern(pattern):
         raise RuleError(f"{pattern}: Pattern should contain a '%'.")
 
 
-def _strip_dot(path):
-    if not path:
-        return path
-    path = Path(path)  # ./aaa/ -> aaa
-    parts = path.parts
-    if ".." in parts:
-        raise RuleError(f"{path}: '..' directory is not allowed")
-    return str(path)
-
-
 def _check_wildcard(path):
     if "*" in path:
         raise RuleError(f"{path}: '*' directory is not allowed")
 
 
-class Rule:
-    def __init__(self, targets, pattern, depends, uses, builder=None):
-        self.targets = []
-        for target in flatten(targets or ()):
-            target = str(target)
-            _check_pattern_count(target)
-            target = _strip_dot(target)
-            target = rule_to_re(target)
-            self.targets.append(target)
+def _name_to_str(name):
+    match name:
+        case Task():
+            return name.name
+        case _TaskFunc():
+            return name.name
+        case Path():
+            return str(name)
+        case str():
+            return name
+        case _:
+            raise ValueError(f"Invalid dependency name: {name}")
 
-        self.first_target = None
-        for target in flatten(targets or ()):
-            target = str(target)
-            if not target:
-                continue
+    return name
 
-            if "*" in target:
-                continue
 
-            if _check_pattern_count(target) == 0:
-                # not contain one %
-                self.first_target = target
-                break
+class Rule:
+    def __init__(self, targets, pattern=None, depends=(), uses=(), builder=None):
+        self.targets = []
+        self.default = False
+        self.first_target = None
+        if targets:
+            for target in flatten(targets):
+                if not target:
+                    continue
+                target = str(target)
+                if not target:
+                    continue
+
+                if not self.first_target:
+                    if "*" not in target:
+                        if _check_pattern_count(target) == 0:
+                            # not contain one %
+                            self.first_target = target
+
+                target = rule_to_re(target)
+                self.targets.append(target)
 
         if pattern:
-            pattern = _strip_dot(pattern)
+            pattern = str(pattern)
             if _check_pattern_count(pattern) != 1:
                 raise RuleError(f"{pattern}: Pattern should contain a '%'")
 
@@ -206,18 +216,16 @@ class Rule:
 
         self.depends = []
         for depend in flatten(depends or ()):
-            depend = str(depend)
+            depend = _name_to_str(depend)
             _check_pattern_count(depend)
             _check_wildcard(depend)
-            depend = _strip_dot(depend)
             self.depends.append(depend)
 
         self.uses = []
         for use in flatten(uses or ()):
-            use = str(use)
+            use = _name_to_str(use)
             _check_pattern_count(use)
             _check_wildcard(use)
-            use = _strip_dot(use)
             self.uses.append(use)
 
         self.builder = builder
@@ -227,6 +235,54 @@ class Rule:
         return f
 
 
+class _TaskFunc:
+    def __init__(self, f, name):
+        self.f = f
+        self.name = name
+
+    def __call__(self, *args, **kwargs):
+        return self.f(*args, **kwargs)
+
+
+def default_builder(*args, **kwargs):
+    # default builder
+    pass
+
+
+class Task(Rule):
+    def __init__(self, name, uses, default, func=None):
+        super().__init__((), pattern=None, depends=(), uses=uses, builder=func)
+        if name:
+            self.name = _name_to_str(name)
+            if name:
+                self.targets = [name]
+                self.first_target = self.name
+        else:
+            self.name = None
+
+        self.default = default
+        if func:
+            self._set_funcname(func)
+        if not self.builder:
+            self.builder = default_builder
+
+    def _set_funcname(self, f):
+        if not self.name:
+            if not f.__name__ or f.__name__ == "<lambda>":
+                raise RuleError(
+                    "Task function should have a name. Use @task(name='name')"
+                )
+            self.name = f.__name__
+            self.targets = [f.__name__]
+
+        self.first_target = self.name
+
+    def __call__(self, f):
+        self.builder = f
+        self._set_funcname(f)
+        return _TaskFunc(f, self.name)
+
+
 class Rules:
     def __init__(self):
         self.rules = []
@@ -234,40 +290,52 @@ class Rules:
         self._detect_loop = set()
         self.frozen = False
 
-    def add_rule(self, targets, pattern, depends, uses, builder):
+    def add_rule(self, targets, pattern=None, depends=(), uses=(), builder=None):
+        if builder:
+            if not callable(builder):
+                raise ValueError(f"{builder} is not callable")
+
         if self.frozen:
             raise RuntimeError("No new rule can be added after initialization")
 
-        dep = Rule(
-            targets,
-            pattern,
-            depends,
-            uses,
-            builder,
-        )
+        dep = Rule(targets, pattern, depends, uses, builder)
+        self.rules.append(dep)
+        return dep
+
+    def add_task(self, name=None, uses=(), default=False, func=None):
+        if self.frozen:
+            raise RuntimeError("No new rule can be added after initialization")
+        dep = Task(name, uses, default, func)
         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)
+    def rule(self, targets, *, pattern=None, depends=(), uses=()):
+        if not targets:
+            raise ValueError("No target specified")
+
+        dep = self.add_rule([targets], pattern, depends, uses, None)
+        return dep
+
+    def task(self, func=None, *, name=None, uses=(), default=False):
+        if func:
+            if not callable(func):
+                raise ValueError(f"{func} is not callable")
+
+        dep = self.add_task(name, uses, default, func)
         return dep
 
     def iter_rule(self, name):
-        name = str(name)
+        name = _name_to_str(name)
         for dep in self.rules:
             for target in dep.targets:
-                m = re.fullmatch(str(target), name)
+                m = re.fullmatch(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)
+                        m = re.fullmatch(dep.pattern, name)
                         if m:
                             stem = m.groupdict().get("stem", None)
 
@@ -282,7 +350,6 @@ class Rules:
                     break
 
     def get_dep_names(self, name):
-        assert name
         ret_depends = []
         ret_uses = []
 
@@ -296,10 +363,16 @@ class Rules:
         return unique_list(ret_depends), unique_list(ret_uses)
 
     def select_first_target(self):
+        first = None
         for dep in self.rules:
+            if dep.default and (not first):
+                first = dep.name
+
             if dep.first_target:
                 return dep.first_target
 
+        return first
+
     def select_builder(self, name):
         for depends, uses, dep in self.iter_rule(name):
             if not dep.builder:
@@ -307,11 +380,13 @@ class Rules:
             return depends, uses, dep
 
     def build_tree(self, name, lv=1):
+        assert name
         self.frozen = True
 
-        name = str(name)
+        name = _name_to_str(name)
         if name in self._detect_loop:
-            raise CircularReferenceError(name)
+            raise CircularReferenceError(f"Circular reference detected: {name}")
+
         self._detect_loop.add(name)
         try:
             if name in self.tree:
@@ -326,7 +401,7 @@ class Rules:
                 depends.extend(build_uses)
 
             depends = unique_list(depends)
-            self.tree[name].update(str(d) for d in depends)
+            self.tree[name].update(depends)
             for dep in depends:
                 self.build_tree(dep, lv=lv + 1)
 
@@ -339,17 +414,19 @@ class Checkers:
         self.checkers = []
 
     def get_checker(self, name):
+        name = _name_to_str(name)
         for targets, f in self.checkers:
             for target in targets:
-                if fnmatch(name, str(target)):
+                if fnmatch(name, target):
                     return f
 
-    def add_check(self, target, f):
-        self.checkers.append((list(t for t in flatten(target)), f))
+    def add_check(self, targets, f):
+        targets = list(map(_name_to_str, flatten(targets or ())))
+        self.checkers.append((targets, f))
 
-    def check(self, target):
+    def check(self, targets):
         def deco(f):
-            self.add_check(target, f)
+            self.add_check(targets, f)
             return f
 
         return deco
@@ -358,10 +435,6 @@ class Checkers:
 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
@@ -421,35 +494,45 @@ def write(filename, s, append=False):
         f.write(s)
 
 
-def quote(s):
-    return shlex.quote(str(s))
-
-
-def squote(*s):
+def quote(*s):
     ret = [shlex.quote(str(x)) for x in flatten(s)]
     return ret
 
 
+def squote(s):
+    s = " ".join(str(e) for e in flatten(s))
+    return shlex.quote(s)
+
+
 def makedirs(path):
     os.makedirs(path, exist_ok=True)
 
 
 class Prod:
     def __init__(self, modulefile, njobs=1, params=None):
-        self.modulefile = Path(modulefile)
+        if modulefile:
+            self.modulefile = Path(modulefile)
+        else:
+            self.modulefile = None
+
         self.rules = Rules()
         self.checkers = Checkers()
         if njobs > 1:
-            self.executor = concurrent.futures.ThreadPoolExecutor(max_workers=njobs)
+            self.executor = concurrent.futures.ThreadPoolExecutor(max_workers=100)
         else:
             self.executor = None
         self.params = Params(params)
+        self.use_git_timestamp = pyprod.args.use_git
+
         self.buildings = {}
-        self.module = self.load_pyprodfile(self.modulefile)
+        self.module = None
+        if self.modulefile:
+            self.module = self.load_pyprodfile(self.modulefile)
         self.built = 0  # number of build execused
 
     def get_module_globals(self):
         globals = {
+            "build": self.build,
             "capture": capture,
             "check": self.checkers.check,
             "environ": Envs(),
@@ -466,6 +549,8 @@ class Prod:
             "rule": self.rules.rule,
             "run": run,
             "shutil": shutil,
+            "task": self.rules.task,
+            "use_git": self.use_git,
             "write": write,
             "MAX_TS": MAX_TS,
             "Path": Path,
@@ -489,65 +574,94 @@ class Prod:
     async def run_in_executor(self, func, *args, **kwargs):
         if self.executor:
             loop = asyncio.get_running_loop()
-            return await loop.run_in_executor(
+            ret = await loop.run_in_executor(
                 self.executor, lambda: func(*args, **kwargs)
             )
         else:
-            return func(*args, **kwargs)
+            ret = func(*args, **kwargs)
+
+        return ret
+
+    def get_file_mtime(self, name):
+        return os.path.getmtime(name)
+
+    def get_file_mtime_git(self, name):
+        ret = subprocess.check_output(
+            ["git", "log", "-1", "--format=%ai", "--", name], text=True
+        ).strip()
+        if not ret:
+            raise FileNotFoundError(f"{name} did not match any file in git")
+
+        # 2025-01-17 00:05:48 +0900
+        return dateutil.parser.parse(ret)
+
+    async def is_exists(self, name):
+        checker = self.checkers.get_checker(name)
+        try:
+            if checker:
+                ret = await self.run_in_executor(checker, name)
+            elif self.use_git_timestamp:
+                ret = await self.run_in_executor(self.get_file_mtime_git, name)
+            else:
+                ret = await self.run_in_executor(self.get_file_mtime, name)
+        except FileNotFoundError:
+            ret = False
+
+        if isinstance(ret, 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)
+
+    def build(self, *deps):
+        children = []
+        for elem in deps:
+            child = [_name_to_str(name) for name in flatten(elem)]
+            children.append(child)
+        self.deps[0:0] = children
+
+    def use_git(self, use):
+        self.use_git_timestamp = use
 
     def get_default_target(self):
         return self.rules.select_first_target()
 
     async def start(self, deps):
+        self.loop = asyncio.get_running_loop()
         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 RuleError(obj)
-            elif callable(obj):
-                self.built += 1
-                task = asyncio.create_task(self.run_in_executor(obj))
-                waitings.append(task)
-            else:
-                raise RuleError(obj)
+        self.deps = deps[:]
+        while self.deps:
+            dep = self.deps.pop(0)
+            await self.schedule([dep])
 
-        await self.build(builds)
-        await asyncio.gather(*waitings)
         return self.built
 
-    async def build(self, deps):
+    async def schedule(self, deps):
+        deps = list(flatten(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))
+                coro = self.run(dep)
+                tasks.append((dep, coro))
                 waits.append(ev)
             else:
                 obj = self.buildings[dep]
                 if isinstance(obj, asyncio.Event):
                     waits.append(obj)
 
-        for dep, task in tasks:
+        results = await asyncio.gather(*(coro for _, coro in tasks))
+        for ret, (dep, _) in zip(results, tasks):
             ev = self.buildings[dep]
             try:
-                self.buildings[dep] = await task
+                self.buildings[dep] = ret
             finally:
                 ev.set()
 
@@ -563,27 +677,8 @@ class Prod:
             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:
-        name = str(name)
-
+        name = _name_to_str(name)
         self.rules.build_tree(name)
         deps, uses = self.rules.get_dep_names(name)
         selected = self.rules.select_builder(name)
@@ -592,11 +687,23 @@ class Prod:
             deps = deps + build_deps
             uses = uses + build_uses
 
-        ts = 0
+        tasks = []
         if deps:
-            ts = await self.build(deps)
+            deps_task = asyncio.create_task(self.schedule(deps))
+            tasks.append(deps_task)
         if uses:
-            await self.build(uses)
+            uses_task = self.schedule(uses)
+            tasks.append(uses_task)
+
+        await asyncio.gather(*tasks)
+        ts = 0
+        if deps:
+            ts = deps_task.result()
+
+        if selected and isinstance(builder, Task):
+            self.built += 1
+            await self.run_in_executor(builder.builder, *build_deps)
+            return MAX_TS
 
         exists = await self.is_exists(name)
 
@@ -608,8 +715,14 @@ class Prod:
             logger.debug("%r already exists", name)
 
         if not exists.exists and not selected:
-            raise NoRuleToMakeTargetError(name)
-        elif selected and ((not exists.exists) or (ts >= MAX_TS) or (exists.ts < ts)):
+            raise NoRuleToMakeTargetError(f"No rule to make target: {name}")
+
+        elif selected and (
+            (not exists.exists)
+            or (ts >= MAX_TS)
+            or (exists.ts < ts)
+            or pyprod.args.rebuild
+        ):
             logger.warning("building: %r", name)
             await self.run_in_executor(builder.builder, name, *build_deps)
             self.built += 1

pyprod/utils.py

@@ -1,13 +1,15 @@
-from collections.abc import Iterable, Sequence
+from collections.abc import Iterable
 
 
-def flatten(seq):
-    if isinstance(seq, str) or (not isinstance(seq, Sequence)):
+def flatten(seq, ignore_none=True):
+    if isinstance(seq, str) or (not isinstance(seq, Iterable)):
         yield seq
         return
 
     for item in seq:
         if isinstance(item, str) or (not isinstance(item, Iterable)):
+            if ignore_none and (item is None):
+                continue
             yield item
         else:
             yield from flatten(item)

pyprod/venv.py

@@ -11,15 +11,15 @@ import pyprod
 from .utils import flatten
 
 THREADID = threading.get_ident()
-pyprodenv = ".pyprod"
 venvdir = None
 
-PYPRODVENV = ".pyprod"
+PYPRODVENV = "pyprod"
 
 
 def makevenv(conffile):
     global venvdir
-    venvdir = Path(".") / f".{conffile.name}{PYPRODVENV}"
+    major, minor = sys.version_info[:2]
+    venvdir = Path(".") / f".{conffile.name}.{major}.{minor}.{PYPRODVENV}"
     if not venvdir.is_dir():
         venv.main([str(venvdir)])
 
@@ -42,6 +42,15 @@ def pip(*args):
         makevenv(pyprod.modulefile)
     args = flatten(args)
     subprocess.run(
-        [venvdir / "bin/python", "-m", "pip", "--no-input", "install", *args],
+        [
+            venvdir / "bin/python",
+            "-m",
+            "pip",
+            "--disable-pip-version-check",
+            "--no-input",
+            "install",
+            "-q",
+            *args,
+        ],
         check=True,
     )

{pyprod-0.3.0.dist-info → pyprod-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyProd
-Version: 0.3.0
+Version: 0.5.0
 Summary: PyProd: More Makeable than Make
 Project-URL: Homepage, https://github.com/atsuoishimoto/pyprod
 Project-URL: Documentation, https://pyprod.readthedocs.io/en/latest/
@@ -12,12 +12,13 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Software Development :: Build Tools
 Requires-Python: >=3.10
+Requires-Dist: python-dateutil
 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://pyprod.readthedocs.io/en/latest/>`_.
+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://pyprod.readthedocs.io/en/stable/>`_.
 
 
 Features
@@ -42,22 +43,26 @@ With PyProd, a traditional Makefile for C can be expressed as a Python script li
 .. code-block:: python
 
     CC = "gcc"
-    CFLAGS = "-I."
+    CFLAGS = "-c -I."
     DEPS = "hello.h"
     OBJS = "hello.o main.o".split()
+    EXE = "hello.exe"
 
     @rule("%.o", depends=("%.c", DEPS))
     def compile(target, src, *deps):
-        run(CC, "-c -o", target, src, CFLAGS)
+        run(CC, "-o", target, src, CFLAGS)
 
-    @rule("hello.exe", depends=OBJS)
+    @rule(EXE, depends=OBJS)
     def link(target, *objs):
         run(CC, "-o", target, objs)
 
+    @task
     def clean():
         run("rm -f", OBJS, "hello.exe")
 
-    all = "hello.exe"
+    @task
+    def rebuild():
+        build(clean, EXE)
 
 
 To run the build script, simply execute:
@@ -67,6 +72,8 @@ To run the build script, simply execute:
     $ cd project
     $ pyprod
 
+Other examples can be found in the `samples <https://github.com/atsuoishimoto/pyprod/tree/main/samples>`_ directory.
+
 License
 -------
 PyProd is licensed under the MIT License. See the `LICENSE <LICENSE>`_ file for more details.

pyprod-0.5.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+pyprod/__init__.py,sha256=LBK46heutvn3KmsCrKIYu8RQikbfnjZaj2xFrXaeCzQ,22
+pyprod/__main__.py,sha256=Vdhw8YA1K3wPMlbJQYL5WqvRzAKVeZ16mZQFO9VRmCo,62
+pyprod/main.py,sha256=O1tkuZzZ7nuoI2DjFyJlKn-2YYn-UL-jsgrxb5EvmVQ,2945
+pyprod/prod.py,sha256=Tdhr3cTnJv3m61157H48WNuFhvQGJ8lZuaSD6R9XspM,20000
+pyprod/utils.py,sha256=6bA06MtxvzcEArAozeJVMgCvoTT185OPEGypM1jjoG0,481
+pyprod/venv.py,sha256=ZNMtHDBdC-eNFJE0-GxDlh6tlGy5Y-2m1r86SqxJJR0,1229
+pyprod-0.5.0.dist-info/METADATA,sha256=q28RfZ10Oodv3EHGo9Fa1x5U42cihFb9XTV-J9uaNFc,2683
+pyprod-0.5.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pyprod-0.5.0.dist-info/entry_points.txt,sha256=zFycf8BYSMRDTiI0jftmcvtkf9XM4MZ4BL3JaIer_ZM,44
+pyprod-0.5.0.dist-info/licenses/LICENSE,sha256=OtPgwnlLrsVEYPnTraun5AqftAT5vUv4rIan-qYj7nE,1071
+pyprod-0.5.0.dist-info/RECORD,,

pyprod-0.3.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-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=r2e-JSHiTw2SOcv-tYFx4aRpVkQbOb5j9vEVrjT0meE,16694
-pyprod/utils.py,sha256=oiiUkSbeqTazbtJ6gz7ZKqG1OvAeV-nV9u_3Y0DCOOM,401
-pyprod/venv.py,sha256=_riw56YQvUOSd55u_1m9ElsqPdjM5qVvIZP6dr9Fzt4,1051
-pyprod-0.3.0.dist-info/METADATA,sha256=t9TMYeBveYE1LFZNpcYJAtOdUo7gPARFHmIZ9p0bnag,2477
-pyprod-0.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pyprod-0.3.0.dist-info/entry_points.txt,sha256=zFycf8BYSMRDTiI0jftmcvtkf9XM4MZ4BL3JaIer_ZM,44
-pyprod-0.3.0.dist-info/licenses/LICENSE,sha256=OtPgwnlLrsVEYPnTraun5AqftAT5vUv4rIan-qYj7nE,1071
-pyprod-0.3.0.dist-info/RECORD,,