elements 3.2.0__tar.gz → 3.4.0__tar.gz

{elements-3.2.0/elements.egg-info → elements-3.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: elements
-Version: 3.2.0
+Version: 3.4.0
 Summary: Building blocks for productive research.
 Home-page: http://github.com/danijar/elements
 Classifier: Intended Audience :: Science/Research
@@ -228,14 +228,14 @@ print(cp.model)
 ### `elements.Timer`
 
 Collect timing statistics about the run time of different parts of a program.
-Measures code inside scopes and can wrap methods into scopes. Returns execution
-count, execution time, fraction of overall program time, and more. The
-resulting statisticse can be added to the logger.
+Measures code inside sections and can wrap methods into sections. Returns
+execution count, execution time, fraction of overall program time, and more.
+The resulting statisticse can be added to the logger.
 
 ```python
 timer = Timer()
 
-timer.scope('foo'):
+timer.section('foo'):
   time.sleep(10)
 
 timer.wrap('name', obj, ['method1', 'method2'])

{elements-3.2.0 → elements-3.4.0}/README.md

@@ -217,14 +217,14 @@ print(cp.model)
 ### `elements.Timer`
 
 Collect timing statistics about the run time of different parts of a program.
-Measures code inside scopes and can wrap methods into scopes. Returns execution
-count, execution time, fraction of overall program time, and more. The
-resulting statisticse can be added to the logger.
+Measures code inside sections and can wrap methods into sections. Returns
+execution count, execution time, fraction of overall program time, and more.
+The resulting statisticse can be added to the logger.
 
 ```python
 timer = Timer()
 
-timer.scope('foo'):
+timer.section('foo'):
   time.sleep(10)
 
 timer.wrap('name', obj, ['method1', 'method2'])

{elements-3.2.0 → elements-3.4.0}/elements/__init__.py

@@ -1,4 +1,4 @@
-__version__ = '3.2.0'
+__version__ = '3.4.0'
 
 from .agg import Agg
 from .checkpoint import Checkpoint

{elements-3.2.0 → elements-3.4.0}/elements/path.py

@@ -166,7 +166,60 @@ class LocalPath(Path):
     shutil.move(self, dest)
 
 
-class GFilePath(Path):
+class GCSPath(Path):
+
+  __slots__ = ('_path',)
+
+  fs = None
+
+  def __init__(self, path):
+    path = str(path)
+    if not (path.startswith('/') or '://' in path):
+      path = os.path.abspath(os.path.expanduser(path))
+    super().__init__(path)
+    if not type(self).fs:
+      import gcsfs
+      type(self).fs = gcsfs.GCSFileSystem()
+
+  @contextlib.contextmanager
+  def open(self, mode='r'):
+    yield self.fs.open(str(self), mode)
+
+  def absolute(self):
+    return self
+
+  def glob(self, pattern):
+    for path in self.fs.glob(f'{str(self)}/{pattern}'):
+      yield type(self)(path)
+
+  def exists(self):
+    return self.fs.exists(str(self))
+
+  def isfile(self):
+    return self.fs.isfile(str(self))
+
+  def isdir(self):
+    return self.fs.isdir(str(self))
+
+  def mkdirs(self):
+    self.fs.makedirs(str(self), exist_ok=True)
+
+  def remove(self):
+    self.fs.rm(str(self), recursive=False)
+
+  def rmtree(self):
+    self.fs.rm(str(self), recursive=True)
+
+  def copy(self, dest):
+    dest = Path(dest)
+    self.fs.copy(str(self), str(dest), recursive=True)
+
+  def move(self, dest):
+    dest = Path(dest)
+    self.fs.mv(self, str(dest), recursive=True)
+
+
+class TFPath(Path):
 
   __slots__ = ('_path',)
 
@@ -220,7 +273,7 @@ class GFilePath(Path):
     self.gfile.rmtree(str(self))
 
   def copy(self, dest):
-    dest = type(self)(dest)
+    dest = Path(dest)
     if self.isfile():
       self.gfile.copy(str(self), str(dest), overwrite=True)
     else:
@@ -232,12 +285,11 @@ class GFilePath(Path):
 
   def move(self, dest):
     dest = Path(dest)
-    if dest.isdir():
-      dest.rmtree()
     self.gfile.rename(self, str(dest), overwrite=True)
 
 
 Path.filesystems = [
-    (GFilePath, lambda path: path.startswith('gs://')),
+    (GCSPath, lambda path: path.startswith('gs://')),
+    (TFPath, lambda path: path.startswith('/cns/')),
     (LocalPath, lambda path: True),
 ]

elements-3.4.0/elements/tree.py

@@ -0,0 +1,41 @@
+from . import printing
+
+
+def map(fn, *trees, isleaf=None):
+  assert trees, 'Provide one or more nested Python structures'
+  kw = dict(isleaf=isleaf)
+  first = trees[0]
+  try:
+    assert all(isinstance(x, type(first)) for x in trees)
+    if isleaf and isleaf(trees[0]):
+      return fn(*trees)
+    if isinstance(first, list):
+      assert all(len(x) == len(first) for x in trees)
+      return [map(
+          fn, *[t[i] for t in trees], **kw) for i in range(len(first))]
+    if isinstance(first, tuple):
+      assert all(len(x) == len(first) for x in trees)
+      return tuple([map(
+          fn, *[t[i] for t in trees], **kw) for i in range(len(first))])
+    if isinstance(first, dict):
+      assert all(set(x.keys()) == set(first.keys()) for x in trees)
+      return {k: map(fn, *[t[k] for t in trees], **kw) for k in first}
+    if hasattr(first, 'keys') and hasattr(first, 'get'):
+      assert all(set(x.keys()) == set(first.keys()) for x in trees)
+      return type(first)(
+          {k: map(fn, *[t[k] for t in trees], **kw) for k in first})
+  except AssertionError:
+    raise TypeError(printing.format_(trees))
+  return fn(*trees)
+
+
+def flatten(tree, isleaf=None):
+  leaves = []
+  map(lambda x: leaves.append(x), tree, isleaf=isleaf)
+  structure = map(lambda x: None, tree, isleaf=isleaf)
+  return tuple(leaves), structure
+
+
+def unflatten(leaves, structure):
+  leaves = iter(tuple(leaves))
+  return map(lambda x: next(leaves), structure)

{elements-3.2.0 → elements-3.4.0/elements.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: elements
-Version: 3.2.0
+Version: 3.4.0
 Summary: Building blocks for productive research.
 Home-page: http://github.com/danijar/elements
 Classifier: Intended Audience :: Science/Research
@@ -228,14 +228,14 @@ print(cp.model)
 ### `elements.Timer`
 
 Collect timing statistics about the run time of different parts of a program.
-Measures code inside scopes and can wrap methods into scopes. Returns execution
-count, execution time, fraction of overall program time, and more. The
-resulting statisticse can be added to the logger.
+Measures code inside sections and can wrap methods into sections. Returns
+execution count, execution time, fraction of overall program time, and more.
+The resulting statisticse can be added to the logger.
 
 ```python
 timer = Timer()
 
-timer.scope('foo'):
+timer.section('foo'):
   time.sleep(10)
 
 timer.wrap('name', obj, ['method1', 'method2'])

{elements-3.2.0 → elements-3.4.0}/elements.egg-info/SOURCES.txt

@@ -29,4 +29,5 @@ elements.egg-info/requires.txt
 elements.egg-info/top_level.txt
 tests/test_basics.py
 tests/test_flags.py
-tests/test_path.py
+tests/test_path.py
+tests/test_tree.py

elements-3.4.0/elements.egg-info/requires.txt

@@ -0,0 +1,5 @@
+colored
+gcsfs
+numpy
+psutil
+ruamel.yaml

{elements-3.2.0 → elements-3.4.0}/requirements-optional.txt

@@ -1,9 +1,6 @@
-colored
 gputil
 matplotlib
 mlflow
-psutil
 pytest
-ruamel.yaml
 tensorflow-cpu
 wandb

elements-3.4.0/requirements.txt

@@ -0,0 +1,5 @@
+colored
+gcsfs
+numpy
+psutil
+ruamel.yaml

elements-3.4.0/tests/test_tree.py

@@ -0,0 +1,70 @@
+import elements
+import pytest
+
+
+class TestTree:
+
+  def test_map_identity(self):
+    tree = {'a': 12, 'b': ['c', (1, 2, 3)]}
+    copy = elements.tree.map(lambda x: x, tree)
+    assert copy == tree
+    assert copy is not tree
+
+  def test_map_double(self):
+    tree = {'a': 12, 'b': ['c', (1, 2, 3)]}
+    ref = {'a': 24, 'b': ['cc', (2, 4, 6)]}
+    res = elements.tree.map(lambda x: x * 2, tree)
+    assert ref == res
+
+  def test_map_multiple(self):
+    tree1 = {'a': 1, 'b': ['foo', (1, 2, 3)]}
+    tree2 = {'a': 2, 'b': ['bar', (10, 20, 30)]}
+    ref = {'a': 3, 'b': ['foobar', (11, 22, 33)]}
+    res = elements.tree.map(lambda x, y: x + y, tree1, tree2)
+    assert ref == res
+    with pytest.raises(TypeError):
+      tree1 = {'a': 1, 'b': ['foo', (1, 2, 3)]}
+      tree2 = {'b': 2}
+      res = elements.tree.map(lambda x, y: x + y, tree1, tree2)
+
+  def test_map_isleaf(self):
+    tree = {'a': 1, 'b': ['foo', (1, 2, 3)]}
+    isleaf = lambda x: isinstance(x, list)
+    leaves = []
+    elements.tree.map(lambda x: leaves.append(x), tree, isleaf=isleaf)
+    assert leaves == [1, ['foo', (1, 2, 3)]]
+
+  def test_map_degenerate(self):
+    assert elements.tree.map(lambda x: 2 * x, ()) == ()
+    assert elements.tree.map(lambda x: 2 * x, 12) == 24
+    assert elements.tree.map(lambda x: 2 * x, [[{}, ()]]) == [[{}, ()]]
+
+  def test_flatten_basic(self):
+    tree = {'a': 12, 'b': ['c', (1, 2, 3)]}
+    leaves, structure = elements.tree.flatten(tree)
+    assert leaves == (12, 'c', 1, 2, 3)
+    assert structure == {'a': None, 'b': [None, (None, None, None)]}
+
+  def test_flatten_isleaf(self):
+    tree = {'a': 12, 'b': ['c', (1, 2, 3)]}
+    isleaf = lambda x: isinstance(x, list)
+    leaves, structure = elements.tree.flatten(tree, isleaf=isleaf)
+    assert leaves == (12, ['c', (1, 2, 3)])
+    assert structure == {'a': None, 'b': None}
+
+  def test_flatten_degenerate(self):
+    assert elements.tree.flatten(()) == ((), ())
+    assert elements.tree.flatten(12) == ((12,), None)
+    assert elements.tree.flatten([[{}, ()]]) == ((), [[{}, ()]])
+
+  def test_unflatten(self):
+    trees = [
+        {'a': 12, 'b': ['c', (1, 2, 3)]},
+        (),
+        12,
+        [[{}, ()]],
+    ]
+    for tree in trees:
+      leaves, structure = elements.tree.flatten(tree)
+      copy = elements.tree.unflatten(leaves, structure)
+      assert copy == tree

elements-3.2.0/elements/tree.py

@@ -1,31 +0,0 @@
-from . import printing
-
-
-def map_(fn, *trees, isleaf=None):
-  assert trees, 'Provide one or more nested Python structures'
-  kw = dict(isleaf=isleaf)
-  first = trees[0]
-  assert all(isinstance(x, type(first)) for x in trees)
-  if isleaf and isleaf(trees):
-    return fn(*trees)
-  if isinstance(first, list):
-    assert all(len(x) == len(first) for x in trees), printing.format_(trees)
-    return [map_(
-        fn, *[t[i] for t in trees], **kw) for i in range(len(first))]
-  if isinstance(first, tuple):
-    assert all(len(x) == len(first) for x in trees), printing.format_(trees)
-    return tuple([map_(
-        fn, *[t[i] for t in trees], **kw) for i in range(len(first))])
-  if isinstance(first, dict):
-    assert all(set(x.keys()) == set(first.keys()) for x in trees), (
-        printing.format_(trees))
-    return {k: map_(fn, *[t[k] for t in trees], **kw) for k in first}
-  if hasattr(first, 'keys') and hasattr(first, 'get'):
-    assert all(set(x.keys()) == set(first.keys()) for x in trees), (
-        printing.format_(trees))
-    return type(first)(
-        {k: map_(fn, *[t[k] for t in trees], **kw) for k in first})
-  return fn(*trees)
-
-
-map = map_

elements-3.2.0/elements.egg-info/requires.txt

@@ -1 +0,0 @@
-numpy

elements-3.2.0/requirements.txt

@@ -1 +0,0 @@
-numpy