hypster 0.0.1a0__tar.gz

hypster-0.0.1a0/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.1
+Name: hypster
+Version: 0.0.1a0
+Summary: A flexible configuration system for Python projects
+Home-page: https://github.com/hypster-dev/hypster
+License: MIT
+Keywords: configuration,ai,machine-learning
+Author: Gilad Rubin
+Author-email: gilad.rubin@gmail.com
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Project-URL: Repository, https://github.com/hypster-dev/hypster
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <img src="assets/hypster_with_text.png" alt="Hypster Logo" width="600"/>
+</p>
+
+Hypster is a lightweight configuration system for AI & Machine Learning projects. 
+It offers minimal, intuitive syntax, supporting hierarchical and swappable configurations with lazy instantiation - making it both powerful and easy to integrate with existing projects.
+
+## Installation
+
+You can install Hypster using pip:
+
+```bash
+pip install hypster
+```
+
+## Quick Start
+
+Here's a simple example of how to use Hypster:
+
+```python
+%%writefile configs.py
+from hypster import lazy, Options
+
+@dataclass
+class DatabaseConfig:
+    host: str
+    port: int
+
+@dataclass
+class CacheConfig:
+    type: str
+
+# "lazy" defers instantiation
+lazy([Database, Cache], update_globals=True)
+
+# Define configuration options
+db_host = Options({"production": "prod.example.com", 
+                   "staging": "staging.example.com"}, default="staging")
+cache_type = Options(["memory", "redis"], default="memory")
+db_port = Options({"main": 5432, "alt": 5433}, default="main")
+
+# Create lazy instances
+db = Database(host=db_host, port=db_port)
+cache = Cache(type=cache_type)
+```
+
+Now, in another cell or module, you can instantiate the configuration:
+
+```python
+from hypster import Composer
+import configs
+
+config = Composer().with_modules(configs).compose()
+
+result = config.instantiate(
+    final_vars=["db", "cache"],
+    selections={"db.host": "production", "cache.type": "redis"},
+    overrides={"db.port": 8000}
+)
+
+db.connect()  # Outputs: Connecting to prod.example.com:5434
+cache.initialize()  # Outputs: Initializing redis cache
+```
+## Inspiration
+Hypster draws inspiration from [Meta's Hydra](https://github.com/facebookresearch/hydra) and [hydra-zen](https://github.com/mit-ll-responsible-ai/hydra-zen) packages, combining their powerful configuration management with a minimalist approach. 
+
+The API design is also influenced by the elegant simplicity of [Hamilton's API](https://github.com/DAGWorks-Inc/hamilton).
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

hypster-0.0.1a0/README.md

@@ -0,0 +1,75 @@
+<p align="center">
+  <img src="assets/hypster_with_text.png" alt="Hypster Logo" width="600"/>
+</p>
+
+Hypster is a lightweight configuration system for AI & Machine Learning projects. 
+It offers minimal, intuitive syntax, supporting hierarchical and swappable configurations with lazy instantiation - making it both powerful and easy to integrate with existing projects.
+
+## Installation
+
+You can install Hypster using pip:
+
+```bash
+pip install hypster
+```
+
+## Quick Start
+
+Here's a simple example of how to use Hypster:
+
+```python
+%%writefile configs.py
+from hypster import lazy, Options
+
+@dataclass
+class DatabaseConfig:
+    host: str
+    port: int
+
+@dataclass
+class CacheConfig:
+    type: str
+
+# "lazy" defers instantiation
+lazy([Database, Cache], update_globals=True)
+
+# Define configuration options
+db_host = Options({"production": "prod.example.com", 
+                   "staging": "staging.example.com"}, default="staging")
+cache_type = Options(["memory", "redis"], default="memory")
+db_port = Options({"main": 5432, "alt": 5433}, default="main")
+
+# Create lazy instances
+db = Database(host=db_host, port=db_port)
+cache = Cache(type=cache_type)
+```
+
+Now, in another cell or module, you can instantiate the configuration:
+
+```python
+from hypster import Composer
+import configs
+
+config = Composer().with_modules(configs).compose()
+
+result = config.instantiate(
+    final_vars=["db", "cache"],
+    selections={"db.host": "production", "cache.type": "redis"},
+    overrides={"db.port": 8000}
+)
+
+db.connect()  # Outputs: Connecting to prod.example.com:5434
+cache.initialize()  # Outputs: Initializing redis cache
+```
+## Inspiration
+Hypster draws inspiration from [Meta's Hydra](https://github.com/facebookresearch/hydra) and [hydra-zen](https://github.com/mit-ll-responsible-ai/hydra-zen) packages, combining their powerful configuration management with a minimalist approach. 
+
+The API design is also influenced by the elegant simplicity of [Hamilton's API](https://github.com/DAGWorks-Inc/hamilton).
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

hypster-0.0.1a0/pyproject.toml

@@ -0,0 +1,30 @@
+[tool.poetry]
+name = "hypster"
+version = "0.0.1a0"
+description = "A flexible configuration system for Python projects"
+
+authors = ["Gilad Rubin <gilad.rubin@gmail.com>"]
+license = "MIT"
+readme = "README.md"
+repository = "https://github.com/hypster-dev/hypster"
+keywords = ["configuration", "ai", "machine-learning"]
+
+[tool.poetry.dependencies]
+python = "^3.10"
+
+[tool.poetry.dev-dependencies]
+pytest = "^6.0"
+ruff = "^0.1.0"
+mypy = "^0.950"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.ruff]
+line-length = 120
+target-version = "py310"
+
+[tool.mypy]
+ignore_missing_imports = true
+strict_optional = true

hypster-0.0.1a0/src/hypster/__init__.py

@@ -0,0 +1,3 @@
+from .core import config, save, load, HP
+
+__all__ = ["config", "save", "load", "HP"]

hypster-0.0.1a0/src/hypster/ast_analyzer.py

@@ -0,0 +1,278 @@
+import ast
+from typing import Any, Dict, List, Tuple
+
+from .logging_utils import configure_logging
+
+logger = configure_logging()
+
+class Select:
+    def __init__(self, lineno: int, select_index: int, explicit_name: str = None, implicit_name: str = None):
+        self.lineno = lineno
+        self.select_index = select_index
+        self.explicit_name = explicit_name
+        self.implicit_name = implicit_name
+
+class VariableGraphBuilder(ast.NodeVisitor):
+    def __init__(self):
+        self.graph = {}
+        self.current_path = []
+
+    def visit_Assign(self, node):
+        target = self.get_target_name(node.targets[0])
+        logger.debug(f"VariableGraphBuilder: Visiting assignment to {target}")
+        self.current_path = [target]
+        self.graph[target] = self.build_subgraph(node.value)
+
+    def build_subgraph(self, node):
+        logger.debug(f"VariableGraphBuilder: Building subgraph for node type {type(node).__name__}")
+        if isinstance(node, ast.Dict):
+            return {self.get_key_name(k): self.build_subgraph(v) for k, v in zip(node.keys, node.values)}
+        elif isinstance(node, ast.Call):
+            return {
+                '__call__': self.get_target_name(node.func),
+                'args': [self.get_node_value(arg) for arg in node.args],
+                'kwargs': {kw.arg: self.get_node_value(kw.value) for kw in node.keywords}
+            }
+        elif isinstance(node, (ast.Name, ast.Attribute)):
+            return self.get_target_name(node)
+        elif isinstance(node, ast.Constant):
+            return node.value
+        else:
+            return {'__unknown__': ast.unparse(node)}
+
+    def get_node_value(self, node):
+        if isinstance(node, ast.Constant):
+            return node.value
+        elif isinstance(node, (ast.Name, ast.Attribute)):
+            return self.get_target_name(node)
+        else:
+            return ast.unparse(node)
+
+    def get_target_name(self, node):
+        if isinstance(node, ast.Name):
+            return node.id
+        elif isinstance(node, ast.Attribute):
+            return f"{self.get_target_name(node.value)}.{node.attr}"
+        else:
+            return "Unknown"
+
+    def get_key_name(self, node):
+        if isinstance(node, ast.Str):
+            return node.s
+        return self.get_target_name(node)
+
+class HPSelectAnalyzer(ast.NodeVisitor):
+    def __init__(self, variable_graph):
+        self.variable_graph = variable_graph
+        self.results = {}
+        self.current_assignment = None
+        self.current_complex_assignment = None
+        self.selects = []
+
+    def visit_Assign(self, node):
+        logger.debug(f"HPSelectAnalyzer: Visiting assignment on line {node.lineno}")
+        self.current_assignment = node
+        start_line = node.lineno
+        end_line = self.get_last_line(node)
+        
+        if isinstance(node.value, (ast.Dict, ast.Call)):
+            self.current_complex_assignment = node
+        
+        self.results[start_line] = {'code': ast.unparse(node), 'selects': [], 'end_line': end_line}
+        self.generic_visit(node)
+        
+        self.current_complex_assignment = None
+        self.current_assignment = None
+
+    def visit_Call(self, node):
+        if self.is_hp_select(node):
+            logger.debug(f"HPSelectAnalyzer: hp.select call detected on line {node.lineno}")
+            line_number = node.lineno
+            select_index = len([s for s in self.selects if s.lineno == line_number])
+            
+            explicit_name = self.get_hp_select_name(node)
+            inferred_name = self.infer_name(node)
+            
+            if not explicit_name and inferred_name and self.is_valid_inference(inferred_name):
+                implicit_name = inferred_name
+            else:
+                implicit_name = None
+            
+            select = Select(line_number, select_index, explicit_name, implicit_name)
+            self.selects.append(select)
+            
+            if self.current_complex_assignment and self.current_complex_assignment.lineno <= line_number <= self.get_last_line(self.current_complex_assignment):
+                logger.debug(f"HPSelectAnalyzer: hp.select is part of a complex assignment starting on line {self.current_complex_assignment.lineno}")
+                line_number = self.current_complex_assignment.lineno
+            
+            if line_number in self.results:
+                self.results[line_number]['selects'].append(select)
+            else:
+                self.results[line_number] = {
+                    'code': ast.unparse(self.current_complex_assignment or node),
+                    'selects': [select],
+                    'end_line': self.get_last_line(self.current_complex_assignment or node)
+                }
+        
+        self.generic_visit(node)
+
+    def is_valid_inference(self, inferred_name):
+        logger.debug(f"HPSelectAnalyzer: Checking validity of inferred name: {inferred_name}")
+        parts = inferred_name.split('.')
+        valid = len(parts) <= 4 and all(not part.startswith('arg') for part in parts)
+        logger.debug(f"HPSelectAnalyzer: Inferred name {'is' if valid else 'is not'} valid")
+        return valid
+
+    def get_last_line(self, node):
+        return max(getattr(node, 'lineno', 0), getattr(node, 'end_lineno', 0))
+
+    def is_hp_select(self, node):
+        return (isinstance(node.func, ast.Attribute) and
+                isinstance(node.func.value, ast.Name) and
+                node.func.value.id == 'hp' and
+                node.func.attr == 'select')
+
+    def get_hp_select_name(self, node):
+        logger.debug(f"HPSelectAnalyzer: Attempting to get hp.select name for node on line {node.lineno}")
+        if len(node.args) >= 2:
+            name = self.get_node_value(node.args[1])
+            logger.debug(f"HPSelectAnalyzer: Found name in second argument: {name}")
+            return name
+        for keyword in node.keywords:
+            if keyword.arg == 'name':
+                name = self.get_node_value(keyword.value)
+                logger.debug(f"HPSelectAnalyzer: Found name in keyword argument: {name}")
+                return name
+        logger.debug("HPSelectAnalyzer: No explicit name found for hp.select")
+        return None
+
+    def get_node_value(self, node):
+        if isinstance(node, ast.Constant):
+            return node.value
+        elif isinstance(node, ast.Name):
+            return node.id
+        else:
+            return ast.unparse(node)
+
+    def infer_name(self, node):
+        logger.debug(f"HPSelectAnalyzer: Attempting to infer name for node on line {node.lineno}")
+        if self.current_assignment:
+            target = self.get_target_name(self.current_assignment.targets[0])
+            if isinstance(self.current_assignment.value, ast.Call) and self.is_hp_select(self.current_assignment.value):
+                logger.debug(f"HPSelectAnalyzer: Direct assignment to hp.select detected: {target}")
+                return target
+            inferred = self.find_node_in_assignment(self.current_assignment.value, node, [target])
+            logger.debug(f"HPSelectAnalyzer: Inferred name from current assignment: {inferred}")
+            return inferred
+        
+        for var, subgraph in self.variable_graph.items():
+            path = self.find_node_in_graph(subgraph, node)
+            if path:
+                inferred = '.'.join([var] + [p for p in path if p != 'kwargs'])
+                logger.debug(f"HPSelectAnalyzer: Inferred name from variable graph: {inferred}")
+                return inferred
+        logger.debug("HPSelectAnalyzer: Unable to infer name")
+        return None
+
+    def find_node_in_assignment(self, value_node, target_node, path):
+        logger.debug(f"HPSelectAnalyzer: Searching for node in assignment, current path: {'.'.join(path)}")
+        if isinstance(value_node, ast.Dict):
+            for key, value in zip(value_node.keys, value_node.values):
+                if value == target_node:
+                    result = '.'.join(path + [self.get_node_value(key)])
+                    logger.debug(f"HPSelectAnalyzer: Found node in dictionary: {result}")
+                    return result
+                result = self.find_node_in_assignment(value, target_node, path + [self.get_node_value(key)])
+                if result:
+                    return result
+        elif isinstance(value_node, ast.Call):
+            for idx, arg in enumerate(value_node.args):
+                if arg == target_node:
+                    result = '.'.join(path + [f'arg{idx}'])
+                    logger.debug(f"HPSelectAnalyzer: Found node in function argument: {result}")
+                    return result
+                result = self.find_node_in_assignment(arg, target_node, path + [f'arg{idx}'])
+                if result:
+                    return result
+            for keyword in value_node.keywords:
+                if keyword.value == target_node:
+                    result = '.'.join(path + [keyword.arg])
+                    logger.debug(f"HPSelectAnalyzer: Found node in keyword argument: {result}")
+                    return result
+                result = self.find_node_in_assignment(keyword.value, target_node, path + [keyword.arg])
+                if result:
+                    return result
+        logger.debug("HPSelectAnalyzer: Node not found in assignment")
+        return None
+
+    def find_node_in_graph(self, graph, node, path=None):
+        if path is None:
+            path = []
+        
+        logger.debug(f"HPSelectAnalyzer: Searching for node in graph, current path: {'.'.join(path)}")
+        if isinstance(graph, dict):
+            if graph.get('__call__') == 'hp.select' and graph['args'] and self.get_node_value(node.args[0]) == graph['args'][0]:
+                logger.debug(f"HPSelectAnalyzer: Found matching hp.select in graph at path: {'.'.join(path)}")
+                return path
+            for key, value in graph.items():
+                new_path = self.find_node_in_graph(value, node, path + [key])
+                if new_path:
+                    return new_path
+        elif isinstance(graph, list):
+            for i, item in enumerate(graph):
+                new_path = self.find_node_in_graph(item, node, path + [str(i)])
+                if new_path:
+                    return new_path
+        logger.debug("HPSelectAnalyzer: Node not found in graph")
+        return None
+
+    def get_target_name(self, node):
+        if isinstance(node, ast.Name):
+            return node.id
+        elif isinstance(node, ast.Attribute):
+            return f"{self.get_target_name(node.value)}.{node.attr}"
+        else:
+            return "Unknown"
+
+def analyze_hp_select(code: str) -> Tuple[Dict[int, Dict[str, Any]], List[Select]]:
+    logger.info("Starting hp.select analysis")
+    tree = ast.parse(code)
+    
+    logger.debug("Building variable graph")
+    graph_builder = VariableGraphBuilder()
+    graph_builder.visit(tree)
+    
+    logger.debug("Analyzing hp.select calls")
+    analyzer = HPSelectAnalyzer(graph_builder.graph)
+    analyzer.visit(tree)
+    
+    logger.info("hp.select analysis complete")
+    return analyzer.results, analyzer.selects
+
+def inject_names(source_code: str, selects: List[Select]) -> str:
+    tree = ast.parse(source_code)
+    
+    class NameInjector(ast.NodeTransformer):
+        def __init__(self, selects):
+            self.selects = selects
+            self.select_index = {}
+
+        def visit_Call(self, node):
+            if isinstance(node.func, ast.Attribute) and isinstance(node.func.value, ast.Name) and node.func.value.id == 'hp' and node.func.attr == 'select':
+                lineno = node.lineno
+                if lineno not in self.select_index:
+                    self.select_index[lineno] = 0
+                else:
+                    self.select_index[lineno] += 1
+
+                select = next((s for s in self.selects if s.lineno == lineno and s.select_index == self.select_index[lineno]), None)
+                
+                if select and not select.explicit_name and select.implicit_name:
+                    # Inject the implicit name as a keyword argument
+                    node.keywords.append(ast.keyword(arg='name', value=ast.Constant(value=select.implicit_name)))
+
+            return self.generic_visit(node)
+
+    injector = NameInjector(selects)
+    modified_tree = injector.visit(tree)
+    return ast.unparse(modified_tree)

hypster-0.0.1a0/src/hypster/core.py

@@ -0,0 +1,399 @@
+# core.py
+
+import ast
+import inspect
+import types
+from typing import Any, Callable, Dict, List, Union, Optional
+
+from .logging_utils import configure_logging
+from .ast_analyzer import inject_names, analyze_hp_select
+
+logger = configure_logging()
+
+class HP:
+    def __init__(self, final_vars: List[str], selections: Dict[str, Any], overrides: Dict[str, Any]):
+        self.final_vars = final_vars
+        self.selections = selections
+        self.overrides = overrides
+        self.config_dict = {}
+        logger.info("Initialized HP with final_vars: %s, selections: %s, and overrides: %s", 
+                    self.final_vars, self.selections, self.overrides)
+
+    def select(self, options: Union[Dict[str, Any], List[Any]], name: str = None, default: Any = None):
+        if name is None:
+            raise ValueError("Name must be provided explicitly or automatically inferred.")
+
+        if isinstance(options, dict):
+            if not all(isinstance(k, str) for k in options.keys()):
+                bad_keys = [key for key in options.keys() if not isinstance(key, str)]
+                raise ValueError(f"Dictionary keys must be strings. got {bad_keys} instead.")
+        elif isinstance(options, list):
+            if not all(isinstance(v, (str, int, bool, float)) for v in options):
+                raise ValueError("List values must be one of: str, int, bool, float.")
+            options = {v: v for v in options}
+        else:
+            raise ValueError("Options must be a dictionary or a list.")
+
+        if default is not None and default not in options:
+            raise ValueError("Default value must be one of the options.")
+
+        logger.debug("Select called with options: %s, name: %s, default: %s", options, name, default)
+
+        result = None
+        if name in self.overrides:
+            override_value = self.overrides[name]
+            logger.debug("Found override for %s: %s", name, override_value)
+            if override_value in options:
+                result = options[override_value]
+            else:
+                result = override_value
+            logger.info("Applied override for %s: %s", name, result)
+        elif name in self.selections:
+            selected_value = self.selections[name]
+            logger.debug("Found selection for %s: %s", name, selected_value)
+            if selected_value in options:
+                result = options[selected_value]
+                logger.info("Applied selection for %s: %s", name, result)
+            else:
+                raise InvalidSelectionError(
+                    f"Invalid selection '{selected_value}' for '{name}'. Not in options: {list(options.keys())}"
+                )
+        elif default is not None:
+            result = options[default]
+        else:
+            raise ValueError(f"No selection or override found for {name} and no default provided.")
+
+        self.config_dict[name] = result
+        return result
+
+    def propagate(self, config_func: Callable, name: str) -> Dict[str, Any]:
+        logger.info(f"Propagating configuration for {name}")
+        
+        # Create dictionaries for the nested configuration
+        nested_selections = {k[len(name)+1:]: v for k, v in self.selections.items() if k.startswith(f"{name}.")}
+        nested_overrides = {k[len(name)+1:]: v for k, v in self.overrides.items() if k.startswith(f"{name}.")}
+        
+        # Automatically propagate final_vars
+        nested_final_vars = [var[len(name)+1:] for var in self.final_vars if var.startswith(f"{name}.")]
+        
+        logger.debug(f"Propagated configuration for {name} with Selections:\n{nested_selections}\n& Overrides:\n{nested_overrides}\nAuto-propagated final vars: {nested_final_vars}")
+        result = config_func(final_vars=nested_final_vars, selections=nested_selections, overrides=nested_overrides)
+        return result
+
+class Hypster:
+    def __init__(self, func: Callable, source_code: str = None):
+        self.func = func
+        self.source_code = source_code or inspect.getsource(func)
+
+    def __call__(self, final_vars: List[str] = [], selections: Dict[str, Any] = {}, overrides: Dict[str, Any] = {}):
+        logger.info("Hypster called with final_vars: %s, selections: %s, overrides: %s", 
+                    final_vars, selections, overrides)
+        try:
+            hp = HP(final_vars, selections, overrides)
+
+            # Analyze and modify the source code
+            results, selects = analyze_hp_select(self.source_code)
+            modified_source = inject_names(self.source_code, selects)
+            
+            # Extract the function body
+            function_body = self._extract_function_body(modified_source)
+
+            # Create a new namespace and add the 'hp' object to it
+            namespace = {'hp': hp}
+
+            # Execute the modified function body in this namespace
+            exec(function_body, globals(), namespace)
+
+            # Process and filter the results
+            final_result = self._process_results(namespace)
+
+            if not final_vars:
+                return final_result
+            else:
+                result = {k: final_result.get(k, None) for k in final_vars}
+                logger.debug("Final result after filtering by final_vars: %s", result)
+                return result
+
+        except Exception as e:
+            logger.error("An error occurred: %s", str(e))
+            raise
+        
+    def save(self, path: str):
+        save(self, path)
+        
+    def _extract_function_body(self, source: str) -> str:
+        lines = source.split('\n')
+        body_start = next(i for i, line in enumerate(lines) if line.strip().endswith(':'))
+        body_lines = lines[body_start + 1:]
+        min_indent = min(len(line) - len(line.lstrip()) for line in body_lines if line.strip())
+        return '\n'.join(line[min_indent:] for line in body_lines)
+
+    def _process_results(self, namespace: Dict[str, Any]) -> Dict[str, Any]:
+        filtered_locals = {
+            k: v for k, v in namespace.items()
+            if k != 'hp' and not k.startswith('__') and not isinstance(v, (types.ModuleType, types.FunctionType, type))
+        }
+
+        final_result = {k: v for k, v in filtered_locals.items() if not k.startswith('_')}
+
+        logger.debug("Captured locals: %s", filtered_locals)
+        logger.debug("Final result after filtering: %s", final_result)
+
+        return final_result
+
+def config(func: Callable) -> Hypster:
+    return Hypster(func)
+
+def save(hypster_instance: Hypster, path: Optional[str] = None):
+    if not isinstance(hypster_instance, Hypster):
+        raise ValueError("The provided object is not a Hypster instance")
+
+    if path is None:
+        path = f"{hypster_instance.func.__name__}.py"
+
+    # Parse the source code into an AST
+    tree = ast.parse(hypster_instance.source_code)
+
+    # Find the function definition and remove decorators
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef):
+            node.decorator_list = []
+            break
+
+    # Convert the modified AST back to source code
+    modified_source = ast.unparse(tree)
+
+    with open(path, "w") as f:
+        f.write(modified_source)
+
+    logger.info("Configuration saved to %s", path)
+
+def load(path: str) -> Hypster:
+    with open(path, "r") as f:
+        source = f.read()
+
+    # Execute the source code to define the function
+    namespace = {}
+    exec(source, namespace)
+
+    # Find the function in the namespace
+    for name, obj in namespace.items():
+        if callable(obj) and not name.startswith("__"):
+            # Create and return a Hypster instance with the source code
+            return Hypster(obj, source_code=source)
+
+    raise ValueError("No suitable function found in the source code")
+
+class InvalidSelectionError(Exception):
+    pass
+
+# # core.py
+
+# import ast
+# import inspect
+# from typing import Any, Callable, Dict, List, Union, Optional
+
+# from .logging_utils import configure_logging
+
+# logger = configure_logging()
+
+
+# class HP:
+#     def __init__(self, selections: Dict[str, Any], overrides: Dict[str, Any]):
+#         self.selections = selections
+#         self.overrides = overrides
+#         self.config_dict = {}
+#         logger.info("Initialized HP with selections: %s and overrides: %s", self.selections, self.overrides)
+
+#     def select(self, options: Union[Dict[str, Any], List[Any]], name: str = None, default: Any = None):
+#         if name is None:
+#             raise ValueError("Name must be provided explicitly or automatically inferred.")
+
+#         if isinstance(options, dict):
+#             if not all(isinstance(k, str) for k in options.keys()):
+#                 bad_keys = [key for key in options.keys() if not isinstance(key, str)]
+#                 raise ValueError(f"Dictionary keys must be strings. got {bad_keys} instead.")
+#         elif isinstance(options, list):
+#             if not all(isinstance(v, (str, int, bool, float)) for v in options):
+#                 raise ValueError("List values must be one of: str, int, bool, float.")
+#             options = {v: v for v in options}
+#         else:
+#             raise ValueError("Options must be a dictionary or a list.")
+
+#         if default is not None and default not in options:
+#             raise ValueError("Default value must be one of the options.")
+
+#         logger.debug("Select called with options: %s, name: %s, default: %s", options, name, default)
+
+#         result = None
+#         if name in self.overrides:
+#             override_value = self.overrides[name]
+#             logger.debug("Found override for %s: %s", name, override_value)
+#             if override_value in options:
+#                 result = options[override_value]
+#             else:
+#                 result = override_value
+#             logger.info("Applied override for %s: %s", name, result)
+#         elif name in self.selections:
+#             selected_value = self.selections[name]
+#             logger.debug("Found selection for %s: %s", name, selected_value)
+#             if selected_value in options:
+#                 result = options[selected_value]
+#                 logger.info("Applied selection for %s: %s", name, result)
+#             else:
+#                 raise InvalidSelectionError(
+#                     f"Invalid selection '{selected_value}' for '{name}'. Not in options: {list(options.keys())}"
+#                 )
+#         elif default is not None:
+#             result = options[default]
+#         else:
+#             raise ValueError(f"No selection or override found for {name} and no default provided.")
+
+#         self.config_dict[name] = result
+#         return result
+    
+#     def propagate(self, config_func: Callable, name: str) -> Dict[str, Any]:
+#         logger.info(f"Propagating configuration for {name}")
+        
+#         # Create a new HP instance for the nested configuration
+#         nested_selections = {k[len(name)+1:]: v for k, v in self.selections.items() if k.startswith(f"{name}.")}
+#         nested_overrides = {k[len(name)+1:]: v for k, v in self.overrides.items() if k.startswith(f"{name}.")}
+#         #nested_hp = HP(nested_selections, nested_overrides)
+        
+#         # Execute the nested configuration function
+#         logger.debug(f"Propagated configuration for {name} with Selections:\n{nested_selections}\n& Overrides:\n{nested_overrides}")
+#         return config_func(selections=nested_selections, overrides=nested_overrides)
+
+# import ast
+# import inspect
+# import types
+# from typing import Any, Callable, Dict, List, Union
+# from .logging_utils import configure_logging
+# from .ast_analyzer import inject_names, analyze_hp_select
+
+# logger = configure_logging()
+
+# class Hypster:
+#     def __init__(self, func: Callable, source_code: str = None):
+#         self.func = func
+#         self.source_code = source_code or inspect.getsource(func)
+
+#     def __call__(self, final_vars: List[str] = [], selections: Dict[str, Any] = {}, overrides: Dict[str, Any] = {}):
+#         logger.info("Hypster called with final_vars: %s, selections: %s, overrides: %s", 
+#                     final_vars, selections, overrides)
+#         try:
+#             hp = HP(selections, overrides)
+
+#             # Analyze and modify the source code
+#             results, selects = analyze_hp_select(self.source_code)
+#             modified_source = inject_names(self.source_code, selects)
+            
+#             # Extract the function body
+#             function_body = self._extract_function_body(modified_source)
+
+#             # Create a new namespace and add the 'hp' object to it
+#             namespace = {'hp': hp}
+
+#             # Execute the modified function body in this namespace
+#             exec(function_body, globals(), namespace)
+
+#             # Process and filter the results
+#             final_result = self._process_results(namespace)
+
+#             if not final_vars:
+#                 return final_result
+#             else:
+#                 result = {k: final_result.get(k, None) for k in final_vars}
+#                 logger.debug("Final result after filtering by final_vars: %s", result)
+#                 return result
+
+#         except Exception as e:
+#             logger.error("An error occurred: %s", str(e))
+#             raise
+        
+#     def save(self, path: str):
+#         save(self, path)
+        
+#     def _extract_function_body(self, source: str) -> str:
+#         lines = source.split('\n')
+#         body_start = next(i for i, line in enumerate(lines) if line.strip().endswith(':'))
+#         body_lines = lines[body_start + 1:]
+#         min_indent = min(len(line) - len(line.lstrip()) for line in body_lines if line.strip())
+#         return '\n'.join(line[min_indent:] for line in body_lines)
+
+#     def _process_results(self, namespace: Dict[str, Any]) -> Dict[str, Any]:
+#         filtered_locals = {
+#             k: v for k, v in namespace.items()
+#             if k != 'hp' and not k.startswith('__') and not isinstance(v, (types.ModuleType, types.FunctionType, type))
+#         }
+
+#         final_result = {k: v for k, v in filtered_locals.items() if not k.startswith('_')}
+
+#         logger.debug("Captured locals: %s", filtered_locals)
+#         logger.debug("Final result after filtering: %s", final_result)
+
+#         return final_result
+
+# def config(func: Callable) -> Hypster:
+#     return Hypster(func)
+
+# def save(hypster_instance: Hypster, path: Optional[str] = None):
+#     if not isinstance(hypster_instance, Hypster):
+#         raise ValueError("The provided object is not a Hypster instance")
+
+#     if path is None:
+#         path = f"{hypster_instance.func.__name__}.py"
+
+#     # Parse the source code into an AST
+#     tree = ast.parse(hypster_instance.source_code)
+
+#     # Find the function definition and remove decorators
+#     for node in ast.walk(tree):
+#         if isinstance(node, ast.FunctionDef):
+#             node.decorator_list = []
+#             break
+
+#     # Convert the modified AST back to source code
+#     modified_source = ast.unparse(tree)
+
+#     with open(path, "w") as f:
+#         f.write(modified_source)
+
+#     logger.info("Configuration saved to %s", path)
+
+# def load(path: str) -> Hypster:
+#     with open(path, "r") as f:
+#         source = f.read()
+
+#     # Execute the source code to define the function
+#     namespace = {}
+#     exec(source, namespace)
+
+#     # Find the function in the namespace
+#     for name, obj in namespace.items():
+#         if callable(obj) and not name.startswith("__"):
+#             # Create and return a Hypster instance with the source code
+#             return Hypster(obj, source_code=source)
+
+#     raise ValueError("No suitable function found in the source code")
+
+# class InvalidSelectionError(Exception):
+#     pass
+
+# # Example usage (can be commented out in the actual module)
+# """
+# @config
+# def my_config(hp):
+#     hp.select(["a", "b", "c"], name="a", default="a")
+#     hp.select({"x": 1, "y": 2}, name="b", default="x")
+
+# # Save the configuration
+# save(my_config, "my_config.py")
+
+# # Load the configuration
+# loaded_config = load("my_config.py")
+
+# # Use the loaded configuration
+# result = loaded_config(final_vars=["a"], selections={"b": "y"}, overrides={"a": "c"})
+# print(result)
+# """

hypster-0.0.1a0/src/hypster/logging_utils.py

@@ -0,0 +1,55 @@
+import logging
+
+class CustomFormatter(logging.Formatter):
+    BLACK = "\033[0;30m"
+    RED = "\033[0;31m"
+    GREEN = "\033[0;32m"
+    BROWN = "\033[0;33m"
+    BLUE = "\033[0;34m"
+    PURPLE = "\033[0;35m"
+    CYAN = "\033[0;36m"
+    LIGHT_GRAY = "\033[0;37m"
+    DARK_GRAY = "\033[1;30m"
+    LIGHT_RED = "\033[1;31m"
+    LIGHT_GREEN = "\033[1;32m"
+    YELLOW = "\033[1;33m"
+    LIGHT_BLUE = "\033[1;34m"
+    LIGHT_PURPLE = "\033[1;35m"
+    LIGHT_CYAN = "\033[1;36m"
+    LIGHT_WHITE = "\033[1;37m"
+    BOLD = "\033[1m"
+    FAINT = "\033[2m"
+    ITALIC = "\033[3m"
+    UNDERLINE = "\033[4m"
+    BLINK = "\033[5m"
+    NEGATIVE = "\033[7m"
+    CROSSED = "\033[9m"
+    END = "\033[0m"
+    reset = "\x1b[0m"
+    format = "%(message)s"
+
+    FORMATS = {
+        logging.DEBUG: CYAN + "%(levelname)s" + reset + " - " + format,
+        logging.INFO: GREEN + "%(levelname)s" + reset + " - " + format,
+        logging.WARNING: YELLOW + "%(levelname)s" + reset + " - " + format,
+        logging.ERROR: RED + "%(levelname)s" + reset + " - " + format,
+    }
+
+# Logging Configuration Function
+def configure_logging():
+    # Get the root logger
+    logger = logging.getLogger()
+
+    # Remove all existing handlers
+    if logger.hasHandlers():
+        logger.handlers.clear()
+
+    # Initialize the handler with the custom formatter
+    handler = logging.StreamHandler()
+    handler.setFormatter(CustomFormatter())
+
+    # Set the handler for the logger
+    logger.addHandler(handler)
+    logger.setLevel(logging.WARNING)
+
+    return logger