partis-pyproj 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

{partis_pyproj-0.1.4.data → partis_pyproj-0.1.6.data}/purelib/partis/pyproj/pyproj.py

@@ -1,8 +1,11 @@
+from __future__ import annotations
 import os
 import os.path as osp
 import sys
 import shutil
-import logging
+from logging import (
+  getLogger,
+  Logger)
 import tempfile
 from copy import copy, deepcopy
 from collections.abc import (
@@ -27,7 +30,6 @@ except ImportError:
 from .pkginfo import (
   PkgInfoReq,
   PkgInfo )
-
 from .validate import (
   ValidationWarning,
   ValidationError,
@@ -38,17 +40,16 @@ from .validate import (
   valid,
   restrict,
   mapget )
-
 from .norms import (
   scalar_list,
   norm_bool,
   norm_path_to_os,
   norm_path )
-
 from .pep import (
   purelib_compat_tags,
   platlib_compat_tags )
-
+from .path import (
+  resolve)
 from .load_module import (
   EntryPointError,
   EntryPoint,
@@ -68,7 +69,7 @@ from .builder import (
 from .dist_file import (
   dist_copy )
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class PyProjBase:
   """Minimal build system for a Python project
 
@@ -77,21 +78,21 @@ class PyProjBase:
 
   Parameters
   ----------
-  root : str | pathlib.Path
+  root :
     Path to the root project directory containing 'pyproject.toml'.
-  logger : logging.Logger
+  logger :
     Parent logger to use when processing project.
 
   """
   #-----------------------------------------------------------------------------
   def __init__( self, *,
-    root,
-    config_settings = None,
-    logger = None ):
+    root: Path,
+    config_settings: dict|None = None,
+    logger: Logger|None = None ):
 
-    self.logger = logger or logging.getLogger( __name__ )
+    self.logger = logger or getLogger( __name__ )
 
-    self.root = Path(root).resolve()
+    self.root = resolve(Path(root))
 
     self.pptoml_file = self.root / 'pyproject.toml'
 
@@ -117,6 +118,7 @@ class PyProjBase:
 
     #...........................................................................
     # construct a validator from the tool.pyproj.config table
+    # NOTE: only really used in the event that "config_settings" are passed to the backend
     config_default = dict()
 
     for k,v in self.pyproj.config.items():
@@ -129,14 +131,12 @@ class PyProjBase:
       else:
         config_default[k] = valid(v, type(v))
 
-    class valid_config(valid_dict):
-      _allow_keys = list()
-      _default = config_default
+    class valid_config_settings(valid_dict):
+      allow_keys = list()
+      default = config_default
 
     with validating( key = 'config_settings' ):
-      _config_settings = valid_config(config_settings or dict())
-
-      self.pyproj.config = _config_settings
+      self._config_settings = valid_config_settings(config_settings or dict())
 
     #...........................................................................
     self.build_backend = mapget( self.pptoml,
@@ -196,10 +196,14 @@ class PyProjBase:
 
   #-----------------------------------------------------------------------------
   @property
-  def config(self):
-    """:class:`partis.pyproj.pptoml.pyproj_config`
+  def config_settings(self):
+    """Config settings passed to backend, or defaults from ``pyproj.config``
     """
-    return self._pptoml.tool.pyproj.config
+    return self._config_settings
+
+  #-----------------------------------------------------------------------------
+  # alias for backward compatibility
+  config = config_settings
 
   #-----------------------------------------------------------------------------
   @property
@@ -218,6 +222,9 @@ class PyProjBase:
       These are no longer restricted to meson, but this attribute kept for backward
       compatability.
 
+      Inplace changes to the returned object are not propagated back to the target
+      configuration.
+
     """
     targets = self._pptoml.tool.pyproj.targets
 
@@ -227,6 +234,7 @@ class PyProjBase:
     meson = dict(targets[0])
     meson.pop('entry')
     meson.pop('work_dir')
+    meson.pop('env')
     meson['compile'] = meson.pop('enabled')
     return pyproj_meson(meson)
 
@@ -297,9 +305,9 @@ class PyProjBase:
     dynamic = project.dynamic
 
     self.prep_entrypoint(
-      name = f"tool.pyproj.prep",
+      name = "tool.pyproj.prep",
       obj = self.pyproj,
-      logger = self.logger.getChild( f"prep" ) )
+      logger = self.logger.getChild("prep") )
 
     # NOTE: check that any dynamic meta-data is defined after prep
     for k in dynamic:
@@ -327,9 +335,9 @@ class PyProjBase:
     """
 
     self.prep_entrypoint(
-      name = f"tool.pyproj.dist.prep",
+      name = "tool.pyproj.dist.prep",
       obj = self.dist,
-      logger = self.logger.getChild( f"dist.prep" ) )
+      logger = self.logger.getChild("dist.prep") )
 
 
   #-----------------------------------------------------------------------------
@@ -338,9 +346,9 @@ class PyProjBase:
     """
 
     self.prep_entrypoint(
-      name = f"tool.pyproj.dist.source.prep",
+      name = "tool.pyproj.dist.source.prep",
       obj = self.dist.source,
-      logger = self.logger.getChild( f"dist.source.prep" ) )
+      logger = self.logger.getChild("dist.source.prep") )
 
   #-----------------------------------------------------------------------------
   def dist_source_copy( self, *, dist ):
@@ -352,7 +360,7 @@ class PyProjBase:
       Builder used to write out source distribution files
     """
 
-    with validating( key = f'tool.pyproj.dist.source' ):
+    with validating( key = 'tool.pyproj.dist.source'):
       dist_copy(
         base_path = dist.named_dirs['root'],
         include = self.source.copy,
@@ -362,9 +370,9 @@ class PyProjBase:
         logger = self.logger )
 
       if self.add_legacy_setup:
-        with validating( key = f'add_legacy_setup' ):
+        with validating(key = 'add_legacy_setup'):
 
-          self.logger.info(f"generating legacy 'setup.py'")
+          self.logger.info("generating legacy 'setup.py'")
           legacy_setup_content( self, dist )
 
   #-----------------------------------------------------------------------------
@@ -372,16 +380,19 @@ class PyProjBase:
     """Prepares project files for a binary distribution
     """
 
-    with Builder(
+    builder = Builder(
       pyproj = self,
       root = self.root,
       targets = self.targets,
-      logger = self.logger.getChild( f"targets" ) ):
+      logger = self.logger.getChild("targets"))
+
+    with builder:
+      builder.build_targets()
 
       self.prep_entrypoint(
-        name = f"tool.pyproj.dist.binary.prep",
+        name = "tool.pyproj.dist.binary.prep",
         obj = self.binary,
-        logger = self.logger.getChild( f"dist.binary.prep" ) )
+        logger = self.logger.getChild("dist.binary.prep") )
 
     self.logger.debug(f"Compatibility tags after dist.binary.prep: {self.binary.compat_tags}")
 
@@ -396,7 +407,7 @@ class PyProjBase:
     """
 
 
-    with validating( key = f'tool.pyproj.dist.binary' ):
+    with validating(key = 'tool.pyproj.dist.binary'):
       ignore = self.dist.ignore + self.dist.binary.ignore
 
       dist_copy(

partis_pyproj-0.1.6.data/purelib/partis/pyproj/template.py

@@ -0,0 +1,229 @@
+from __future__ import annotations
+import re
+from copy import copy
+from pathlib import Path
+from collections.abc import (
+  Sequence,
+  Mapping)
+# from string import Template
+
+from .validate import (
+  ValidationError,
+  FileOutsideRootError)
+from .path import (
+  subdir,
+  resolve)
+
+namespace_sep = re.compile(r"[\.\[\]]")
+
+_idpattern = re.compile(r"""(?:
+  # references a template variable
+  [A-Z_][A-Z0-9_]* # Python identifier
+  (?:
+    \.[A-Z_][A-Z0-9_]* # attribute access by Python identifier
+    |
+    \[-?[0-9]+\])* # integer index (potentially negative)
+  |
+  \/ # forward slash separate for building path
+  |
+  (?<=\/)\.\. # double-dot (parent directory), must follow a slash
+  |
+  '[A-Z0-9\-_\.]+' # string literal, quotes to be removed
+  )+
+  """,
+  re.IGNORECASE|re.VERBOSE)
+
+_group_pattern = re.compile(
+  # NOTE: handles escaped '$' and missing closing brace
+  r"\$(?:(?P<escaped>\$)|{ *(?P<braced>[^\s\}]+) *(?:}|(?P<unterminated>$|[^}])))",
+  re.IGNORECASE)
+
+#===============================================================================
+class TemplateError(ValidationError):
+  ...
+
+#===============================================================================
+class NamespaceError(ValidationError):
+  ...
+
+#===============================================================================
+class Template:
+  r"""Template support nested mappings and paths using :class:`Namespace`
+  """
+
+  #-----------------------------------------------------------------------------
+  def __init__(self, template):
+    self.template = template
+
+  #-----------------------------------------------------------------------------
+  def substitute(self, namespace: Mapping = None, /, **kwargs):
+    if namespace is None:
+      namespace = kwargs
+
+    elif kwargs:
+      raise TypeError("Cannot use both namespace and kwargs")
+
+    if not isinstance(namespace, Namespace):
+      namespace = Namespace(namespace)
+
+    def _handler(m):
+      if m.group('escaped'):
+        return '$'
+
+      if m.group('unterminated') is not None:
+        raise TemplateError(f"Unterminated template substitution: {m.group()}")
+
+      name = m.group('braced').strip()
+
+      if not _idpattern.fullmatch(name):
+        raise TemplateError(f"Invalid template substitution: {name}")
+
+      return str(namespace[name])
+
+    return _group_pattern.sub(_handler, self.template)
+
+#===============================================================================
+class Namespace(Mapping):
+  r"""Namespace (potentially nested) mapping for using with :class:`Template`
+
+  Parameters
+  ----------
+  data:
+    Mapping for names to values. Note that changes to the namespace will also
+    change the data. Making a shallow copy of the namespace also make a shallow
+    copy of the data.
+  root:
+    If given, absolute path to project root, used to resolve relative paths and ensure
+    any derived paths are within this parent directory.
+  """
+  __slots__ = ['data', 'root']
+
+  #-----------------------------------------------------------------------------
+  def __init__(self, data: Mapping, *, root: Path = None):
+    self.data = data
+    self.root = root
+
+  #-----------------------------------------------------------------------------
+  def __iter__(self):
+    return iter(self.data)
+
+  #-----------------------------------------------------------------------------
+  def __len__(self):
+    return len(self.data)
+
+  #-----------------------------------------------------------------------------
+  def __setitem__(self, name, value):
+    self.data[name] = value
+
+  #-----------------------------------------------------------------------------
+  def __getitem__(self, key):
+    raw_segments = key.split('/')
+    segments = []
+
+    for name in raw_segments:
+      if len(name) == 0 or name == '..':
+        # empty segment
+        segments.append(name)
+
+      elif name.startswith("'"):
+        # string literal, remove quotes
+        segments.append(name[1:-1])
+
+      else:
+        # variable name lookup
+        segments.append(self.lookup(name))
+
+    if len(segments) == 1:
+      return segments[0]
+
+    if self.root is None:
+      out = Path(*segments)
+
+    else:
+      root = self.root
+      out = type(root)(*segments)
+
+      if not out.is_absolute():
+        out = root/out
+
+      if isinstance(root, Path):
+        # NOTE: ignored if root is a pure path
+        out = resolve(out)
+
+      if not subdir(root, out, check = False):
+        raise FileOutsideRootError(
+          f"Must be within project root directory:"
+          f"\n  file = \"{out}\"\n  root = \"{root}\"")
+
+    return out
+
+  #-----------------------------------------------------------------------------
+  def __copy__(self):
+    cls = type(self)
+    obj = cls.__new__(cls)
+    obj.data = copy(self.data)
+    obj.root = self.root
+    return obj
+
+  #-----------------------------------------------------------------------------
+  def lookup(self, name):
+    parts = namespace_sep.split(name)
+    data = self.data
+
+    try:
+      cur = []
+
+      for k in parts:
+        if k:
+          if isinstance(data, Mapping):
+            data = data[k]
+          elif not isinstance(data, (str,bytes)) and isinstance(data, Sequence):
+            i = int(k)
+            data = data[i]
+          else:
+            raise NamespaceError(f"Expected mapping or sequence for '{k}': {type(data).__name__}")
+
+          cur.append(k)
+
+    except (KeyError,TypeError,IndexError) as e:
+      raise NamespaceError(f"Invalid key '{k}' of name '{name}': {str(e)}") from None
+
+    return data
+
+#===============================================================================
+def template_substitute(
+    value: bool|int|str|Path|Mapping|Sequence,
+    namespace: Mapping):
+  r"""Recursively performs template substitution based on type of value
+  """
+
+  if not isinstance(namespace, Namespace):
+    namespace = Namespace(namespace)
+
+  if isinstance(value, (bool,int)):
+    # just handles case where definitely not a template
+    return value
+
+  cls = type(value)
+
+  if isinstance(value, str):
+    return cls(Template(value).substitute(namespace))
+
+  if isinstance(value, Path):
+    return cls(*(
+      Template(v).substitute(namespace)
+      for v in value.parts))
+
+  if isinstance(value, Mapping):
+    return cls({
+      k: template_substitute(v, namespace)
+      for k,v in value.items()})
+
+  if isinstance(value, Sequence):
+    return cls([
+      template_substitute(v, namespace)
+      for v in value])
+
+
+  raise TypeError(f"Unknown template value type: {value}")
+