PyProd 0.2.0.post1__py3-none-any.whl → 0.4.0__py3-none-any.whl

pyprod/main.py

@@ -14,6 +14,13 @@ parser = argparse.ArgumentParser(
     description="""PyProd - More makable than make""",
 )
 
+parser.add_argument(
+    "-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')"
 )
@@ -27,12 +34,8 @@ 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(
     "-v",
     dest="verbose",
@@ -55,8 +58,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 +97,7 @@ def main():
 
     params = {}
     targets = []
+
     for target in args.targets:
         if "=" in target:
             name, value = target.split("=", 1)
@@ -107,7 +116,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

@@ -33,7 +33,11 @@ class NoRuleToMakeTargetError(Exception):
     pass
 
 
-class InvalidRuleError(Exception):
+class RuleError(Exception):
+    pass
+
+
+class TargetError(Exception):
     pass
 
 
@@ -109,13 +113,11 @@ def glob(path, dir="."):
 
 def rule_to_re(rule):
     if not isinstance(rule, (str, Path)):
-        raise InvalidRuleError(rule)
+        raise TypeError(f"str or Path required: {rule}")
 
     srule = str(rule)
     srule = translate(srule)
     srule = replace_pattern(srule, "(?P<stem>.*)", maxreplace=1)
-    if isinstance(rule, Path):
-        return Path(srule)
     return srule
 
 
@@ -132,44 +134,145 @@ def replace_pattern(rule, replaceto, *, maxreplace=None):
             if maxreplace is not None:
                 if n > maxreplace:
                     # contains multiple '%'
-                    raise InvalidRuleError(s_rule)
+                    raise RuleError(f"{s_rule} contains multiple '%'")
+
             return replaceto
 
     s_rule = re.sub("%%|%", f, s_rule)
-    if isinstance(rule, Path):
-        return Path(s_rule)
     return s_rule
 
 
-@dataclass
+def _check_pattern_count(pattern):
+    """Counts number of '%' in the pattern"""
+    matches = re.finditer(r"%%|%", pattern)
+    num = len([m for m in matches if len(m[0]) == 1])
+    if num > 1:
+        raise RuleError(f"{pattern}: Multiple '%' is not allowed")
+    return num
+
+
+def _check_pattern(pattern):
+    matches = re.finditer(r"%%|%", pattern)
+    singles = [m for m in matches if len(m[0]) == 1]
+    if len(singles) > 1:
+        raise RuleError(f"{pattern}: Multiple '%' is not allowed")
+    if not len(singles):
+        raise RuleError(f"{pattern}: Pattern should contain a '%'.")
+
+
+def _check_wildcard(path):
+    if "*" in path:
+        raise RuleError(f"{path}: '*' directory is not allowed")
+
+
+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
+
+    return name
+
+
 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 __init__(self, targets, pattern=None, depends=(), uses=(), builder=None):
+        self.targets = []
+        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 = str(pattern)
+            if _check_pattern_count(pattern) != 1:
+                raise RuleError(f"{pattern}: Pattern should contain a '%'")
+
+            self.pattern = rule_to_re(pattern)
+        else:
+            self.pattern = None
+
+        self.depends = []
+        for depend in flatten(depends or ()):
+            depend = _name_to_str(depend)
+            _check_pattern_count(depend)
+            _check_wildcard(depend)
+            self.depends.append(depend)
+
+        self.uses = []
+        for use in flatten(uses or ()):
+            use = _name_to_str(use)
+            _check_pattern_count(use)
+            _check_wildcard(use)
+            self.uses.append(use)
+
+        self.builder = builder
 
     def __call__(self, f):
         self.builder = f
         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(self, *args, **kwargs):
+    # default builder
+    pass
+
+
+class Task(Rule):
+    def __init__(self, name, depends, uses, func=None):
+        super().__init__((), pattern=None, depends=depends, uses=uses, builder=func)
+        self.name = _name_to_str(name)
+        if name:
+            self.targets = [name]
+            self.first_target = self.name
+        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 = []
@@ -177,52 +280,66 @@ 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, depends=(), uses=(), func=None):
+        if self.frozen:
+            raise RuntimeError("No new rule can be added after initialization")
+        dep = Task(name, depends, uses, 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, depends=(), uses=()):
+        if func:
+            if not callable(func):
+                raise ValueError(f"{func} is not callable")
+
+        dep = self.add_task(name, depends, uses, 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)
-                        d = m.groupdict().get("stem", None)
-                        if d is not None:
-                            stem = d
+                        m = re.fullmatch(dep.pattern, name)
+                        if m:
+                            stem = m.groupdict().get("stem", None)
 
-                    depends = [replace_pattern(r, stem) for r in dep.depends]
-                    uses = [replace_pattern(r, stem) for r in dep.uses]
+                    if stem is not None:
+                        depends = [replace_pattern(r, stem) for r in dep.depends]
+                        uses = [replace_pattern(r, stem) for r in dep.uses]
+                    else:
+                        depends = dep.depends[:]
+                        uses = dep.uses[:]
 
                     yield depends, uses, dep
                     break
 
     def get_dep_names(self, name):
-        assert name
         ret_depends = []
         ret_uses = []
 
@@ -237,14 +354,8 @@ class Rules:
 
     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
+            if dep.first_target:
+                return dep.first_target
 
     def select_builder(self, name):
         for depends, uses, dep in self.iter_rule(name):
@@ -253,11 +364,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:
@@ -272,7 +385,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)
 
@@ -285,17 +398,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
@@ -356,9 +471,38 @@ class Envs:
         return os.environ.get(name, default=default)
 
 
+def read(filename):
+    with open(filename, "r") as f:
+        return f.read()
+
+
+def write(filename, s, append=False):
+    mode = "a" if append else "w"
+    with open(filename, mode) as f:
+        f.write(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:
@@ -367,23 +511,34 @@ class Prod:
             self.executor = None
         self.params = Params(params)
         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(),
+            "glob": glob,
+            "makedirs": makedirs,
+            "os": os,
+            "params": self.params,
             "pip": pip,
+            "quote": quote,
+            "q": quote,
+            "squote": squote,
+            "sq": squote,
+            "read": read,
             "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,
+            "task": self.rules.task,
+            "write": write,
+            "MAX_TS": MAX_TS,
+            "Path": Path,
         }
         return globals
 
@@ -404,47 +559,28 @@ 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_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 InvalidRuleError(obj)
-            elif callable(obj):
-                self.built += 1
-                task = asyncio.create_task(self.run_in_executor(obj))
-                waitings.append(task)
-            else:
-                raise InvalidRuleError(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):
         tasks = []
         waits = []
         for dep in deps:
@@ -496,12 +632,14 @@ class Prod:
             ret = MAX_TS
         return Exists(name, True, ret)
 
-    async def run(self, name):  # -> Any | int:
-        s_name = str(name)
+    def build(self, *deps):
+        self.deps[0:0] = [_name_to_str(name) for name in flatten(deps)]
 
-        self.rules.build_tree(s_name)
-        deps, uses = self.rules.get_dep_names(s_name)
-        selected = self.rules.select_builder(s_name)
+    async def run(self, name):  # -> Any | int:
+        name = _name_to_str(name)
+        self.rules.build_tree(name)
+        deps, uses = self.rules.get_dep_names(name)
+        selected = self.rules.select_builder(name)
         if selected:
             build_deps, build_uses, builder = selected
             deps = deps + build_deps
@@ -509,23 +647,34 @@ class Prod:
 
         ts = 0
         if deps:
-            ts = await self.build(deps)
+            ts = await self.schedule(deps)
         if uses:
-            await self.build(uses)
+            await self.schedule(uses)
+
+        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(s_name)
+        exists = await self.is_exists(name)
 
         if not exists.exists:
-            logger.debug("%r does not exists", str(s_name))
+            logger.debug("%r does not exists", name)
         elif (ts >= MAX_TS) or (exists.ts < ts):
-            logger.debug("%r should be updated", str(s_name))
+            logger.debug("%r should be updated", name)
         else:
-            logger.debug("%r already exists", str(s_name))
+            logger.debug("%r already exists", 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)
+            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
             return MAX_TS

pyprod/utils.py

@@ -1,8 +1,8 @@
-from collections.abc import Iterable, Sequence
+from collections.abc import Iterable
 
 
 def flatten(seq):
-    if isinstance(seq, str) or (not isinstance(seq, Sequence)):
+    if isinstance(seq, str) or (not isinstance(seq, Iterable)):
         yield seq
         return
 

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)])
 

{pyprod-0.2.0.post1.dist-info → pyprod-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyProd
-Version: 0.2.0.post1
+Version: 0.4.0
 Summary: PyProd: More Makeable than Make
 Project-URL: Homepage, https://github.com/atsuoishimoto/pyprod
 Project-URL: Documentation, https://pyprod.readthedocs.io/en/latest/
@@ -17,7 +17,7 @@ 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 +42,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 +71,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.4.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=w8xm7Dz4eXF6D6FhZuxlPfU24KpnXciJLuAMT6_y3zI,2808
+pyprod/prod.py,sha256=Vu376JyNqiieCMy8jVvBml3TAf32Pq4XxSdpC4bBdgY,18424
+pyprod/utils.py,sha256=hvqeZhXyVAsHAdPUG6LhBOs2dMVXuDUWBYiIPBcsoKw,391
+pyprod/venv.py,sha256=lRTYxvtX876FQ9-bTYmsOHYV3nuMkKHO5hTLog0iHro,1085
+pyprod-0.4.0.dist-info/METADATA,sha256=zkpPbp07U627hgqWE6yDYGe_dZEDQTCiE3FidIfQ5mM,2652
+pyprod-0.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pyprod-0.4.0.dist-info/entry_points.txt,sha256=zFycf8BYSMRDTiI0jftmcvtkf9XM4MZ4BL3JaIer_ZM,44
+pyprod-0.4.0.dist-info/licenses/LICENSE,sha256=OtPgwnlLrsVEYPnTraun5AqftAT5vUv4rIan-qYj7nE,1071
+pyprod-0.4.0.dist-info/RECORD,,

pyprod-0.2.0.post1.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=poLehE5Gs_vEZvKrSdMicF016tQeaMMAnFc76ssPQQY,14586
-pyprod/utils.py,sha256=oiiUkSbeqTazbtJ6gz7ZKqG1OvAeV-nV9u_3Y0DCOOM,401
-pyprod/venv.py,sha256=_riw56YQvUOSd55u_1m9ElsqPdjM5qVvIZP6dr9Fzt4,1051
-pyprod-0.2.0.post1.dist-info/METADATA,sha256=WnpzS2zWCnRZxR9cHjrfkI7yUd742pp5idOzdNyJ7Fk,2483
-pyprod-0.2.0.post1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pyprod-0.2.0.post1.dist-info/entry_points.txt,sha256=zFycf8BYSMRDTiI0jftmcvtkf9XM4MZ4BL3JaIer_ZM,44
-pyprod-0.2.0.post1.dist-info/licenses/LICENSE,sha256=OtPgwnlLrsVEYPnTraun5AqftAT5vUv4rIan-qYj7nE,1071
-pyprod-0.2.0.post1.dist-info/RECORD,,