hypergrid 0.0.1a1__tar.gz

hypergrid-0.0.1a1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 justin-yan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

hypergrid-0.0.1a1/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.1
+Name: hypergrid
+Version: 0.0.1a1
+Summary: Hypergrid is a Python package for the concise declaration and manipulation of parameter grids, making hyperparameter optimization and batch job dispatch more manageable.
+Author-email: Justin Yan <justin@iomorphic.com>
+Project-URL: Homepage, https://github.com/justin-yan/hypergrid
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# hypergrid
+
+Hypergrid is designed to enable concise declaration and manipulation of parameter grids possible, which are often required when tuning ML hyperparameters or defining large batch jobs.
+
+Hypergrid allows you to easily define multi-dimensional parameter grids, and then combine them in various ways, including sum-types, product-types, and co-iteration.  Once defined, you can easily map, filter, select, and apply arbitrary functions in order to easily compose and iterate over your grid.

hypergrid-0.0.1a1/README.md

@@ -0,0 +1,5 @@
+# hypergrid
+
+Hypergrid is designed to enable concise declaration and manipulation of parameter grids possible, which are often required when tuning ML hyperparameters or defining large batch jobs.
+
+Hypergrid allows you to easily define multi-dimensional parameter grids, and then combine them in various ways, including sum-types, product-types, and co-iteration.  Once defined, you can easily map, filter, select, and apply arbitrary functions in order to easily compose and iterate over your grid.

hypergrid-0.0.1a1/pyproject.toml

@@ -0,0 +1,68 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "hypergrid"
+version = "0.0.1a1"
+authors = [
+    { name="Justin Yan", email="justin@iomorphic.com" }
+]
+description = "Hypergrid is a Python package for the concise declaration and manipulation of parameter grids, making hyperparameter optimization and batch job dispatch more manageable."
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+]
+dependencies = [
+]
+
+[project.urls]
+"Homepage" = "https://github.com/justin-yan/hypergrid"
+
+[tool.setuptools]
+zip-safe = false
+include-package-data = true
+
+[tool.setuptools.package-data]
+"hypergrid" = ["py.typed"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+#######
+### Miscellaneous Tool Configuration
+#######
+[tool.black]
+line-length = 150
+skip-string-normalization = true
+target-version = ['py311']
+include = '\.pyi?$'
+
+[tool.ruff]
+select = ["E", "F"]
+line-length = 150
+target-version = "py311"
+
+
+[tool.pytest.ini_options]
+addopts = "-ra -q"
+
+[tool.mypy]
+mypy_path = "src"
+disallow_untyped_defs = true
+disallow_any_unimported = true
+no_implicit_optional = true
+check_untyped_defs = true
+warn_return_any = true
+show_error_codes = true
+warn_unused_ignores = true

hypergrid-0.0.1a1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

hypergrid-0.0.1a1/src/hypergrid/grid.py

@@ -0,0 +1,211 @@
+from __future__ import annotations
+
+import itertools
+from collections import OrderedDict, namedtuple
+from typing import Any, Callable, List, Protocol
+
+
+class IGrid(Protocol):
+    def __repr__(self) -> str:
+        ...
+
+    def __str__(self) -> str:
+        ...
+
+    def __iter__(self) -> Any:
+        ...
+
+    def __add__(self, other: IGrid) -> SumGrid:
+        return SumGrid(self, other)
+
+    def __mul__(self, other: IGrid) -> ProductGrid:
+        return ProductGrid(self, other)
+
+    def __and__(self, other: IGrid) -> CoGrid:
+        return CoGrid(self, other)
+
+    def apply(self, **kwargs: Callable[[Any], Any]) -> IGrid:
+        # TODO: what should we do if no lambda is provided?
+        # TODO: what should the expected signature of the lambda be?  Should we unpack the namedtuple or receive a namedtuple instead?
+        applied_grids = []
+
+        for dim_name, transform in kwargs.items():
+            transformed_elements = [transform(grid_element) for grid_element in self]
+            new_grid = Grid(**{dim_name: transformed_elements})
+            applied_grids.append(new_grid)
+
+        final_co_grid: IGrid = applied_grids[0]
+        for grid in applied_grids[1:]:
+            final_co_grid = CoGrid(final_co_grid, grid)
+
+        return final_co_grid
+
+    def select(self, *dim_names: str) -> IGrid:
+        # TODO: what do we do if no dimnames are provided?
+        selected_elements: dict = {dim_name: [] for dim_name in dim_names}
+
+        for grid_element in self:
+            for dim_name in dim_names:
+                # TODO: How do we want to handle the case when a value isn't present?
+                selected_value = getattr(grid_element, dim_name)
+                selected_elements[dim_name].append(selected_value)
+
+        selected_grids = [Grid(**{dim_name: values}) for dim_name, values in selected_elements.items()]
+
+        final_co_grid: IGrid = selected_grids[0]
+        for grid in selected_grids[1:]:
+            final_co_grid = CoGrid(final_co_grid, grid)
+
+        return final_co_grid
+
+    def map(self, **kwargs: Callable[[Any], Any]) -> MapGrid:
+        return MapGrid(self, **kwargs)
+
+    def filter(self, predicate: Callable[[Any], bool]) -> FilterGrid:
+        return FilterGrid(self, predicate)
+
+
+class SumGrid(IGrid):
+    def __init__(self, grid1: IGrid, grid2: IGrid) -> None:
+        self.grid1 = grid1
+        self.grid2 = grid2
+
+    def __repr__(self) -> str:
+        return f"SumGrid({repr(self.grid1)}, {repr(self.grid2)})"
+
+    def __str__(self) -> str:
+        return f"SumGrid({str(self.grid1)}, {str(self.grid2)})"
+
+    def __iter__(self) -> Any:
+        for grid_element in itertools.chain(self.grid1, self.grid2):
+            yield grid_element
+
+
+class ProductGrid(IGrid):
+    # TODO: Make product grids fail if subdimensions collide?  How does this work with things like maps, etc.?
+    def __init__(self, grid1: IGrid, grid2: IGrid) -> None:
+        self.grid1 = grid1
+        self.grid2 = grid2
+        self.namedtuple_cache: dict = {}
+
+    def __repr__(self) -> str:
+        return f"ProductGrid({repr(self.grid1)}, {repr(self.grid2)})"
+
+    def __str__(self) -> str:
+        return f"ProductGrid({str(self.grid1)}, {str(self.grid2)})"
+
+    def __iter__(self) -> Any:
+        # TODO: is there a way to do this without accessing private attributes?
+        for grid_element1, grid_element2 in itertools.product(self.grid1, self.grid2):
+            field_names1 = grid_element1._fields
+            field_names2 = grid_element2._fields
+            concatenated_field_names = list(field_names1) + list(field_names2)
+            field_names_key = tuple(concatenated_field_names)
+
+            if field_names_key not in self.namedtuple_cache:
+                self.namedtuple_cache[field_names_key] = namedtuple("GridElement", concatenated_field_names)
+
+            concatenated_namedtuple_class = self.namedtuple_cache[field_names_key]
+            concatenated_element = concatenated_namedtuple_class(*(grid_element1 + grid_element2))
+            yield concatenated_element
+
+
+class Grid(IGrid):
+    dimensions: OrderedDict[str, List[Any]]
+
+    def __init__(self, **kwargs: List[Any]) -> None:
+        self.dimensions = OrderedDict()
+        for dim, values in kwargs.items():
+            self.dimensions[dim] = values
+
+    def __repr__(self) -> str:
+        dim_str = ", ".join([f"{dim}={values}" for dim, values in self.dimensions.items()])
+        return f"Grid({dim_str})"
+
+    def __str__(self) -> str:
+        return self.__repr__()
+
+    def __iter__(self) -> Any:
+        fieldnames: tuple = tuple(self.dimensions.keys())
+        namedtuple_class = namedtuple("GridElement", fieldnames)  # type: ignore
+        for element_tuple in itertools.product(*self.dimensions.values()):
+            yield namedtuple_class(*element_tuple)
+
+
+class GridShapeMismatchError(Exception):
+    pass
+
+
+class CoGrid(IGrid):
+    def __init__(self, grid1: IGrid, grid2: IGrid) -> None:
+        if len(list(grid1)) == len(list(grid2)):
+            self.grid1 = grid1
+            self.grid2 = grid2
+            self.namedtuple_cache: dict = {}
+        else:
+            raise GridShapeMismatchError("The shapes of the input grids must be the same")
+
+    def __repr__(self) -> str:
+        return f"CoGrid({repr(self.grid1)}, {repr(self.grid2)})"
+
+    def __str__(self) -> str:
+        return f"CoGrid({str(self.grid1)}, {str(self.grid2)})"
+
+    def __iter__(self) -> Any:
+        for grid_element1, grid_element2 in zip(self.grid1, self.grid2):
+            field_names1 = grid_element1._fields
+            field_names2 = grid_element2._fields
+            concatenated_field_names = list(field_names1) + list(field_names2)
+            field_names_key = tuple(concatenated_field_names)
+
+            if field_names_key not in self.namedtuple_cache:
+                self.namedtuple_cache[field_names_key] = namedtuple("GridElement", concatenated_field_names)
+
+            concatenated_namedtuple_class = self.namedtuple_cache[field_names_key]
+            concatenated_element = concatenated_namedtuple_class(*(grid_element1 + grid_element2))
+            yield concatenated_element
+
+
+class MapGrid(IGrid):
+    def __init__(self, grid: IGrid, **kwargs: Callable[[Any], Any]) -> None:
+        self.grid = grid
+        self.dimension_mapping = kwargs
+        self.namedtuple_cache: dict = {}
+
+    def __repr__(self) -> str:
+        mappings_str = ", ".join([f"{dim_name}={func.__name__}" for dim_name, func in self.dimension_mapping.items()])
+        return f"MapGrid({repr(self.grid)}, {mappings_str})"
+
+    def __str__(self) -> str:
+        return f"MapGrid({str(self.grid)}, {', '.join(self.dimension_mapping.keys())})"
+
+    def __iter__(self) -> Any:
+        for grid_element in self.grid:
+            new_values = {dim_name: func(grid_element) for dim_name, func in self.dimension_mapping.items()}
+            concatenated_values = tuple(grid_element) + tuple(new_values.values())
+            field_names = grid_element._fields + tuple(new_values.keys())
+
+            field_names_key = tuple(field_names)
+            if field_names_key not in self.namedtuple_cache:
+                self.namedtuple_cache[field_names_key] = namedtuple("GridElement", field_names)
+
+            concatenated_namedtuple_class = self.namedtuple_cache[field_names_key]
+            concatenated_element = concatenated_namedtuple_class(*concatenated_values)
+            yield concatenated_element
+
+
+class FilterGrid(IGrid):
+    def __init__(self, grid: IGrid, predicate: Callable[[Any], bool]) -> None:
+        self.grid = grid
+        self.predicate = predicate
+
+    def __repr__(self) -> str:
+        return f"FilterGrid({repr(self.grid)}, {self.predicate.__name__})"
+
+    def __str__(self) -> str:
+        return f"FilterGrid({str(self.grid)}, {self.predicate.__name__})"
+
+    def __iter__(self) -> Any:
+        for grid_element in self.grid:
+            if self.predicate(grid_element):
+                yield grid_element

hypergrid-0.0.1a1/src/hypergrid.egg-info/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.1
+Name: hypergrid
+Version: 0.0.1a1
+Summary: Hypergrid is a Python package for the concise declaration and manipulation of parameter grids, making hyperparameter optimization and batch job dispatch more manageable.
+Author-email: Justin Yan <justin@iomorphic.com>
+Project-URL: Homepage, https://github.com/justin-yan/hypergrid
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# hypergrid
+
+Hypergrid is designed to enable concise declaration and manipulation of parameter grids possible, which are often required when tuning ML hyperparameters or defining large batch jobs.
+
+Hypergrid allows you to easily define multi-dimensional parameter grids, and then combine them in various ways, including sum-types, product-types, and co-iteration.  Once defined, you can easily map, filter, select, and apply arbitrary functions in order to easily compose and iterate over your grid.

hypergrid-0.0.1a1/src/hypergrid.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+src/hypergrid/__init__.py
+src/hypergrid/grid.py
+src/hypergrid/py.typed
+src/hypergrid.egg-info/PKG-INFO
+src/hypergrid.egg-info/SOURCES.txt
+src/hypergrid.egg-info/dependency_links.txt
+src/hypergrid.egg-info/not-zip-safe
+src/hypergrid.egg-info/top_level.txt

hypergrid-0.0.1a1/src/hypergrid.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

hypergrid-0.0.1a1/src/hypergrid.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

hypergrid-0.0.1a1/src/hypergrid.egg-info/top_level.txt

@@ -0,0 +1 @@
+hypergrid