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/legacy.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import os
 import os.path as osp
 from pathlib import PurePath
@@ -7,7 +8,7 @@ import logging
 import tempfile
 
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def legacy_setup_content( pyproj, sdist ):
   """
 
@@ -34,7 +35,7 @@ def legacy_setup_content( pyproj, sdist ):
 
   sources = '\n'.join( [
     os.fspath(file)
-    for file, hash, size in sdist.records ] ).encode('utf-8')
+    for file, (hash, size) in sdist.records.items() ] ).encode('utf-8')
 
   with open( osp.join( osp.dirname(__file__), '_legacy_setup.py' ), 'r' ) as fp:
     legacy_setup_py = fp.read()

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

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import os
 import os.path as osp
 import sys
@@ -22,11 +23,11 @@ from .validate import (
   restrict,
   mapget )
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class EntryPointError(ValueError):
   pass
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def module_name_from_path( path, root ):
   """Generates an importable module name from a file system path
 
@@ -45,7 +46,7 @@ def module_name_from_path( path, root ):
 
   return ".".join(path_parts)
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def module_path( mod_name, root ):
   path = root / Path(*mod_name.split('.'))
 
@@ -59,7 +60,7 @@ def module_path( mod_name, root ):
 
   return path
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def load_module( name, path, root ):
 
   path = str(path)
@@ -82,7 +83,7 @@ def load_module( name, path, root ):
 
   return mod
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def load_entrypoint( entry_point, root ):
   r"""
   Parameters
@@ -129,7 +130,7 @@ def load_entrypoint( entry_point, root ):
 
   return func
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class EntryPoint:
   r"""
 

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

@@ -1,7 +1,10 @@
+from __future__ import annotations
 import sys
 import os
 import os.path as osp
-import io
+from io import (
+  IOBase,
+  BytesIO)
 import warnings
 import stat
 import re
@@ -35,7 +38,7 @@ from .validate import (
   mapget,
   as_list)
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def marker_evaluated(marker):
   if isinstance(marker, bool):
     return marker
@@ -44,7 +47,7 @@ def marker_evaluated(marker):
 
   return marker.evaluate()
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def scalar(val):
   if isinstance(val, str):
     return val
@@ -54,11 +57,11 @@ def scalar(val):
 
   return val
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class scalar_list(valid_list):
-  _value_valid = valid(scalar)
+  value_valid = valid(scalar)
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def norm_bool(val):
   t = [True, 'true', 'True', 'yes', 'y', 'enable', 'enabled']
   f = [False, 'false', 'False', 'no', 'n', 'disable', 'disabled']
@@ -71,7 +74,7 @@ def norm_bool(val):
 
   return val
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def empty_str(val):
   val = str(val)
 
@@ -81,7 +84,7 @@ def empty_str(val):
 
   return val
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def nonempty_str(val):
   val = str(val)
 
@@ -91,42 +94,43 @@ def nonempty_str(val):
 
   return val
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class str_list(valid_list):
-  _value_valid = valid(str)
+  value_valid = valid(str)
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class nonempty_str_list(valid_list):
-  _value_valid = valid(nonempty_str)
+  value_valid = valid(nonempty_str)
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-def norm_data( data ):
+#===============================================================================
+def norm_data(data: str|bytes|IOBase) -> bytes:
   """Normalize data for writing into a distribution
 
   Parameters
   ----------
-  data : bytes | str | io.IOBase
+  data:
+    Data to process
 
   Returns
   -------
-  data : bytes
+  data:
 
     * If data is bytes, it will be returned un-modified.
     * If data is a str, it will be encoded as 'utf-8'.
     * If data is a stream, it will be read to EOF and apply one of the above.
   """
 
-  if isinstance( data, io.IOBase ):
+  if isinstance(data, IOBase):
     # read from a stream, assumes readable
     data = data.read()
 
-  if isinstance( data, str ):
+  if isinstance(data, str):
     # encode text as utf-8
     data = data.encode('utf-8')
 
   return data
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def norm_path( path ):
   """Normalizes a file path for writing into a distribution archive
 
@@ -168,7 +172,7 @@ def norm_path( path ):
 
   return path
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def norm_path_to_os( path ):
   """Converts a normalized or OS path to be an OS path
   """
@@ -184,7 +188,7 @@ def norm_path_to_os( path ):
 
   return str(pathlib.PurePath(path))
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def norm_mode( mode = None ):
   """Normalizes file permission mode for distribution archive
 
@@ -233,7 +237,7 @@ def norm_mode( mode = None ):
 
   return _mode
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def norm_zip_external_attr( mode = None ):
   """Converts the unix integer mode to zip external_attr
 
@@ -269,7 +273,7 @@ def norm_zip_external_attr( mode = None ):
 
   return xattr
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def b64_nopad( data ):
   """Encodes hash as urlsafe base64 encoding with no trailing '=' (:pep:`427`)
 
@@ -287,13 +291,13 @@ def b64_nopad( data ):
   """
   return urlsafe_b64encode( data ).decode("ascii").rstrip("=")
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-def hash_sha256( stream ):
+#===============================================================================
+def hash_sha256(stream: BytesIO):
   """Computes SHA-256 hash
 
   Parameters
   ----------
-  stream : bytes | io.BytesIO
+  stream:
 
   Returns
   -------
@@ -306,7 +310,7 @@ def hash_sha256( stream ):
   """
 
   if isinstance( stream, bytes ):
-    with io.BytesIO( stream ) as _stream:
+    with BytesIO( stream ) as _stream:
       return hash_sha256( _stream )
 
   hasher = hashlib.sha256()
@@ -329,7 +333,7 @@ def hash_sha256( stream ):
 
   return digest_b64_nopad, size
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def email_encode_items(
   headers,
   payload = None ):
@@ -358,7 +362,7 @@ def email_encode_items(
   if payload is not None:
     msg.set_payload( payload )
 
-  buffer = io.BytesIO()
+  buffer = BytesIO()
 
   gen = BytesGenerator(
     buffer,
@@ -373,7 +377,7 @@ def email_encode_items(
 
   return bytes
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class TimeEncode:
   digits = '0123456789abcdefghijklmnopqrstuvwxyz'
 
@@ -425,7 +429,7 @@ class TimeEncode:
 
     return f'{ts:0>{self.width}}'
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 # File/directory names that are invalid on windows
 windows_invalid_filename = '|'.join([
   # filename ending with a period

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

@@ -1,6 +1,7 @@
 from .utils import (
   PathError,
-  subdir )
+  subdir,
+  resolve)
 
 from .pattern import (
   PathPatternError,

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

@@ -1,5 +1,6 @@
-import os
+from __future__ import annotations
 import os.path as osp
+from os import PathLike
 import pathlib
 from pathlib import (
   PurePath,
@@ -13,19 +14,19 @@ from .pattern import (
   tr_path,
   tr_rel_join )
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class PathMatcher:
   r"""Pattern matching similar to '.gitignore'
 
   Parameters
   ----------
-  pattern: str
+  pattern:
     See notes below on pattern formatting.
-  negate: bool
+  negate:
     A match to this pattern negates an existing match of the same name.
-  dironly: bool
+  dironly:
     This pattern is to only match the name of a directory.
-  relative: bool
+  relative:
     This pattern is to match relative paths instead of just the base name.
 
   Notes
@@ -82,10 +83,10 @@ class PathMatcher:
   """
   #-----------------------------------------------------------------------------
   def __init__(self,
-    pattern,
-    negate = False,
-    dironly = False,
-    relative = False ):
+    pattern: str,
+    negate: bool = False,
+    dironly: bool = False,
+    relative: bool = False):
 
     pattern = str(pattern).strip()
     _pattern = pattern
@@ -95,7 +96,7 @@ class PathMatcher:
       negate = True
       pattern = pattern[1:]
 
-    elif pattern.startswith('\!'):
+    elif pattern.startswith(r'\!'):
       # Put a backslash ("\") in front of the first "!" for patterns that begin
       # with a literal "!", for example, "\!important!.txt".
       pattern = pattern[1:]
@@ -146,19 +147,15 @@ class PathMatcher:
     return f"{type(self).__name__}({args})"
 
   #-----------------------------------------------------------------------------
-  def __call__(self, path):
-    return self.match(path)
-
-  #-----------------------------------------------------------------------------
-  def match(self, path):
+  def match(self, path: PathLike) -> bool:
     """
     Parameters
     ----------
-    path: str | pathlib.PurePath
+    path:
 
     Returns
     -------
-    matched : bool
+    matched :
       True if the ``path`` matches this pattern
 
     """
@@ -171,28 +168,34 @@ class PathMatcher:
     return self._match(_path)
 
   #-----------------------------------------------------------------------------
-  def nt(self, path):
+  __call__ = match
+
+  #-----------------------------------------------------------------------------
+  def nt(self, path: PathLike) -> bool:
     """Convenience method to force match as a Windows path
     """
     return self(PureWindowsPath(path))
 
   #-----------------------------------------------------------------------------
-  def posix(self, path):
+  def posix(self, path: PathLike) -> bool:
     """Convenience method to force match as a POSIX path
     """
     return self(PurePosixPath(path))
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 class PathFilter:
   """A combination of file patters applied relative to a given 'start' directory
 
   Parameters
   ----------
-  patterns : list[str | PathMatcher]
-  start : None | pathlib.PurePath
+  patterns:
+  start:
   """
   #-----------------------------------------------------------------------------
-  def __init__(self, patterns = None, start = None):
+  def __init__(self,
+      patterns: list[str|PathMatcher] = None,
+      start: PathLike|None = None):
+
     if patterns is None:
       patterns = []
 
@@ -213,30 +216,33 @@ class PathFilter:
     self._start = _start
 
   #-----------------------------------------------------------------------------
-  def filter(self, dir, fnames, dnames = None, feasible = None):
+  def filter(self,
+      dir: PathLike,
+      fnames: list[str],
+      dnames: list[str]|None = None,
+      feasible: set[str]|None = None) -> set[str]:
     """Filter a list of names in a directory
 
     Parameters
     ----------
-    dir : PathLike | PurePath
+    dir:
       Directory containing ``dnames`` and ``fnames``.
-    fnames : list[str]
+    fnames:
       List of file (non-directory) names in ``dir``.
-
-    dnames : None | list[str]
+    dnames:
       List of directory names in ``dir``.
 
       .. note::
 
         If None, any fnames ending with '/' will be used as (directory) dnames.
 
-    feasible : None | set[str]
+    feasible:
       The current feasible set of names (from either dnames or fnames) that have
       been matched.
 
     Returns
     -------
-    feasible : set[str]
+    feasible:
       Updated feasible set of matched names. It is possible that the input
       feasible set contains names that are *not* in the output if a pattern
       negates an existing match.
@@ -290,13 +296,13 @@ class PathFilter:
     return feasible
 
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def contains(a, b):
   a = str(a)
   b = str(b)
   return a == osp.commonpath([a, b])
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def partition(test, vals):
   """Separates a single list into two lists
 
@@ -322,7 +328,7 @@ def partition(test, vals):
 
   return x, y
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def partition_dir(dir, names):
   """Separates a list of names into those that are directorys and all others.
   """
@@ -330,7 +336,7 @@ def partition_dir(dir, names):
     lambda name: not osp.isdir(osp.join(dir, name)),
     names )
 
-#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#===============================================================================
 def combine_ignore_patterns(*patterns):
   """Creates a callable as ``ignore``
 
@@ -342,6 +348,7 @@ def combine_ignore_patterns(*patterns):
   -------
   callable(dir, names) -> matches
   """
+  # TODO: implement as callable object instead of closure for possible inspection
 
   def _ignore_patterns(dir, names):
     dir = PurePath(dir)