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

{partis_pyproj-0.1.4.data → partis_pyproj-0.1.5.data}/purelib/partis/pyproj/path/pattern.py

@@ -1,21 +1,22 @@
+from __future__ import annotations
 import os
 import os.path as osp
+from pathlib import PurePath
 import re
 from collections import namedtuple
 
 from .utils import _subdir
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class PathPatternError(ValueError):
   pass
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 # NOTE: The regular expressions are constructed to match path separators defined
 # by these (non-printable) control characters, unlikely to be in any filename,
-# making them independent from 'os.path.sep'.
-# The paths to be matched, though, must be translated to this form as well
-# based on the OS-specific representation.
-
+# making them independent from 'os.path.sep', instead of specializing the patterns
+# to each flavor.
+# The paths to be matched, though, must be translated to this form.
 # File Separator (E.G. '/')
 SEP = chr(0x1c)
 # Group Separator (E.G. '.')
@@ -29,17 +30,18 @@ PARDIR = chr(0x1e)
 # CURDIR = '.'
 # PARDIR = '..'
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-def tr_path(path):
+#===============================================================================
+def tr_path(path: PurePath) -> str:
   """Translates path to be compatible with the translated regex.match
 
   Parameters
   ---------
-  path: PurePath
+  path:
+    Path to be translated
 
   Returns
   -------
-  tr_path : str
+  tr_path:
     Translated path, with each path segment separated by :data:`SEP`.
   """
   parts = path.parts
@@ -53,13 +55,14 @@ def tr_path(path):
 
   return SEP.join(parts)
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-def inv_path(path):
-  """
+#===============================================================================
+def inv_path(path: str, sep: str = osp.sep) -> str:
+  """Convert translated path back to os path
   """
-  return osp.sep.join(path.split(SEP))
+  return sep.join(path.split(SEP))
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
+# The glob pattern is defined using POSIX paths, even if matching other flavors
 # path separator (NOTE: except for a trailing recursive "/**")
 re_sep = r'(?P<sep>/(?!\*\*\Z))'
 # fixed (no wildcard) segment
@@ -92,25 +95,24 @@ re_glob = '|'.join([
 rec_glob = re.compile(re_glob)
 rec_unescape = re.compile(r'\\([*?[])')
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-def tr_rel_join(start, dir, names):
+#===============================================================================
+def tr_rel_join(start: str, dir: str, names: list[str]) -> list[tuple[str, str]]:
   """Creates paths relative to a 'start' path for a list of names in a 'dir'
   'start' and 'dir' must already be translated by :func:`tr_path`.
 
   Parameters
   ----------
-  start : str
+  start:
     Starting directory, already translated by :func:`tr_path`.
-  dir : str
+  dir: str
     Directory to compute relative path to, *must* be a sub-directory of `start`,
     already translated by :func:`tr_path`.
-  names : list[str]
+  names:
     List of names in `dir`
 
   Returns
   -------
-  list[tuple[str, str]]
-    List of names joined with path relative to `start`
+  List of names joined with path relative to `start`
   """
 
   rpath = tr_subdir( start, dir )
@@ -120,8 +122,8 @@ def tr_rel_join(start, dir, names):
     (name, tr_join(rpath, name))
     for name in names ]
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-def tr_join(*args):
+#===============================================================================
+def tr_join(*args: str):
   """Joins paths already translated by :func:`tr_path`.
   """
 
@@ -129,21 +131,21 @@ def tr_join(*args):
 
   return SEP.join(args)
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-def tr_subdir(start, path):
+#===============================================================================
+def tr_subdir(start: str, path: str) -> str:
   """Relative path, restricted to sub-directories.
 
   Parameters
   ----------
-  start : str
+  start:
     Starting directory, already translated by :func:`tr_path`.
-  path : str
+  path:
     Directory to compute relative path to, *must* be a sub-directory of `start`,
     already translated by :func:`tr_path`.
 
   Returns
   -------
-  rpath : str
+  rpath:
     Relative path from `start` to `path`.
   """
 
@@ -160,45 +162,49 @@ def tr_subdir(start, path):
     raise PathPatternError(f"Not a subdirectory of {inv_path(start)}: {inv_path(path)}")
 
   return SEP.join(_rpath)
-  
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+#===============================================================================
 class GRef(namedtuple('GRef', ['ori', 'case', 'start', 'end'])):
+  r"""Helps track how a regex was constructed from a glob pattern
+  """
   __slots__ = ()
 
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class GCase:
+  r"""Container for constructing parts of a regex from glob pattern
+  """
   #-----------------------------------------------------------------------------
-  def __init__(self, ref = None):
+  def __init__(self, ref: GRef|None = None):
     if ref is None:
       ref = GRef(None, 'undefined', None, None)
 
     self.ref = ref
 
   #-----------------------------------------------------------------------------
-  def regex(self):
+  def regex(self) -> str:
     raise NotImplementedError("")
 
   #-----------------------------------------------------------------------------
   def __str__(self):
     return self.regex()
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class GStr(GCase):
   #-----------------------------------------------------------------------------
-  def __init__(self, regex, ref = None):
+  def __init__(self, regex: str, ref: GRef|None = None):
     super().__init__(ref = ref)
 
     self._regex = regex
 
   #-----------------------------------------------------------------------------
-  def regex(self):
+  def regex(self) -> str:
     return self._regex
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class GList(GCase):
   #-----------------------------------------------------------------------------
-  def __init__(self, parts = None, ref = None):
+  def __init__(self, parts: list[str] = None, ref: GRef|None = None):
     super().__init__(ref = ref)
 
     if parts is None:
@@ -207,34 +213,34 @@ class GList(GCase):
     self.parts = parts
 
   #-----------------------------------------------------------------------------
-  def regex(self):
+  def regex(self) -> str:
     return ''.join([v.regex() for v in self.parts])
 
   #-----------------------------------------------------------------------------
-  def append(self, val):
+  def append(self, val: str):
     self.parts.append(val)
 
   #-----------------------------------------------------------------------------
   def __str__(self):
     return self._regex
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class GName(GStr):
   pass
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class GFixed(GName):
   pass
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class GChrSet(GName):
   pass
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 GCHR = GName(rf'[^{SEP}]')
 GANY = GName(rf'[^{SEP}]*')
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def reduce_any(pid, sid, n, i, working):
   r"""
   Parameters
@@ -314,7 +320,7 @@ def reduce_any(pid, sid, n, i, working):
 
   return pat
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class GSegment(GList):
   #-----------------------------------------------------------------------------
   def __init__(self, pid, sid, parts = None, ref = None):
@@ -355,7 +361,7 @@ class GSegment(GList):
 
     return ''.join(combined)
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class GSeparator(GStr):
   pass
 
@@ -363,12 +369,12 @@ GSEP = GSeparator(SEP)
 GSUBDIR = GSeparator(rf'([^{SEP}]+{SEP})*')
 GALLDIR = GSeparator(rf'({SEP}[^{SEP}]+)+')
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class GPath(list):
   def regex(self):
     return ''.join([v.regex() for v in self])
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class PatternError(ValueError):
   #-----------------------------------------------------------------------------
   def __init__(self, msg, pat, segs):
@@ -381,7 +387,7 @@ class PatternError(ValueError):
     self.pat = pat
     self.segs = segs
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def esc_chrset(c):
   if c == '/':
     raise PathPatternError("Path separator '/' in character range is undefined.")
@@ -391,7 +397,7 @@ def esc_chrset(c):
 
   return c
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def tr_range(pat):
 
   # range
@@ -416,7 +422,7 @@ def tr_range(pat):
 
   return f"{esc_chrset(a)}-{esc_chrset(d)}"
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def tr_chrset(pat):
   n = len(pat)
 
@@ -467,7 +473,7 @@ def tr_chrset(pat):
 
   return ''.join(parts)
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def tr_glob(pat, pid = 0):
   """
   Notes

partis_pyproj-0.1.5.data/purelib/partis/pyproj/path/utils.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+import sys
+from os import (
+  curdir,
+  pardir,
+  fspath)
+from os.path import (
+  realpath)
+from pathlib import (
+  Path,
+  PurePath)
+
+#===============================================================================
+class PathError(ValueError):
+  pass
+
+#===============================================================================
+def resolve(path: Path):
+  r"""Backport of latest Path.resolve behavior
+  """
+  return type(path)(realpath(fspath(path)))
+
+#===============================================================================
+def _concretize(comps: list[str]) -> list[str]|None:
+  r"""Mostly equivalent to :func:`os.path.normpath`, except for the cases where
+  a concrete path is not possible or would be truncated.
+
+  For example, the path `a/../b` can be normalized to the concrete path `b`,
+  but `a/../../b` depends the name of a's parent directory.
+  """
+
+  new_comps = []
+
+  for comp in comps:
+    if not comp or comp == curdir:
+      continue
+
+    if comp == pardir:
+      if not new_comps:
+        # concrete path not possible
+        return None
+
+      new_comps.pop()
+    else:
+      new_comps.append(comp)
+
+  return new_comps
+
+#===============================================================================
+def _subdir(_start: list[str], _path: list[str]) -> list[str]|None:
+  r"""Concrete path relative to start, or `None` if path is not a sub-directory
+  """
+
+  if (_start := _concretize(_start)) is None:
+    return None
+
+  if (_path := _concretize(_path)) is None:
+    return None
+
+  n = len(_start)
+
+  if len(_path) < n or _path[:n] != _start:
+    return None
+
+  return _path[n:]
+
+#===============================================================================
+def subdir(start: PurePath, path: PurePath, check: bool = True) -> PurePath|None:
+  """Relative path, restricted to sub-directories.
+
+  Parameters
+  ----------
+  start:
+    Starting directory.
+  path:
+    Directory to compute relative path to, *must* be a sub-directory of `start`.
+  check:
+    If True, raises exception if not a subdirectory. Otherwise returns None.
+
+  Returns
+  -------
+  rpath:
+    Relative path from `start` to `path`.
+  """
+
+  _rpath = _subdir(start.parts, path.parts)
+
+  if _rpath is None:
+    if check:
+      raise PathError(f"Not a subdirectory of {start}: {path}")
+
+    return None
+
+  return type(path)(*_rpath)