Add Library management functionality
parent
7cad46fa46
commit
aa5696d884
@ -0,0 +1 @@
|
|||||||
|
from .library import Library, PatternGenerator
|
@ -0,0 +1,267 @@
|
|||||||
|
"""
|
||||||
|
Library class for managing unique name->pattern mappings and
|
||||||
|
deferred loading or creation.
|
||||||
|
"""
|
||||||
|
from typing import Dict, Callable, TypeVar, Generic, TYPE_CHECKING, Any, Tuple, Union
|
||||||
|
import logging
|
||||||
|
from pprint import pformat
|
||||||
|
from dataclasses import dataclass
|
||||||
|
from functools import lru_cache
|
||||||
|
|
||||||
|
from ..error import LibraryError
|
||||||
|
|
||||||
|
if TYPE_CHECKING:
|
||||||
|
from ..pattern import Pattern
|
||||||
|
|
||||||
|
|
||||||
|
logger = logging.getLogger(__name__)
|
||||||
|
|
||||||
|
|
||||||
|
@dataclass
|
||||||
|
class PatternGenerator:
|
||||||
|
__slots__ = ('tag', 'gen')
|
||||||
|
tag: str
|
||||||
|
""" Unique identifier for the source """
|
||||||
|
|
||||||
|
gen: Callable[[], 'Pattern']
|
||||||
|
""" Function which generates a pattern when called """
|
||||||
|
|
||||||
|
|
||||||
|
L = TypeVar('L', bound='Library')
|
||||||
|
|
||||||
|
|
||||||
|
class Library:
|
||||||
|
"""
|
||||||
|
This class is usually used to create a device library by mapping names to
|
||||||
|
functions which generate or load the relevant `Pattern` object as-needed.
|
||||||
|
|
||||||
|
Generated/loaded patterns can have "symbolic" references, where a SubPattern
|
||||||
|
object `sp` has a `None`-valued `sp.pattern` attribute, in which case the
|
||||||
|
Library expects `sp.identifier[0]` to contain a string which specifies the
|
||||||
|
referenced pattern's name.
|
||||||
|
|
||||||
|
Patterns can either be "primary" (default) or "secondary". Both get the
|
||||||
|
same deferred-load behavior, but "secondary" patterns may have conflicting
|
||||||
|
names and are not accessible through basic []-indexing. They are only used
|
||||||
|
to fill symbolic references in cases where there is no "primary" pattern
|
||||||
|
available, and only if both the referencing and referenced pattern-generators'
|
||||||
|
`tag` values match (i.e., only if they came from the same source).
|
||||||
|
|
||||||
|
Primary patterns can be turned into secondary patterns with the `demote`
|
||||||
|
method, `promote` performs the reverse (secondary -> primary) operation.
|
||||||
|
|
||||||
|
The `set_const` and `set_value` methods provide an easy way to transparently
|
||||||
|
construct PatternGenerator objects and directly set create "secondary"
|
||||||
|
patterns.
|
||||||
|
|
||||||
|
The cache can be disabled by setting the `enable_cache` attribute to `False`.
|
||||||
|
"""
|
||||||
|
primary: Dict[str, PatternGenerator]
|
||||||
|
secondary: Dict[Tuple[str, str], PatternGenerator]
|
||||||
|
cache: Dict[Union[str, Tuple[str, str]], 'Pattern']
|
||||||
|
enable_cache: bool = True
|
||||||
|
|
||||||
|
def __init__(self) -> None:
|
||||||
|
self.primary = {}
|
||||||
|
self.secondary = {}
|
||||||
|
self.cache = {}
|
||||||
|
|
||||||
|
def __setitem__(self, key: str, value: PatternGenerator) -> None:
|
||||||
|
self.primary[key] = value
|
||||||
|
if key in self.cache:
|
||||||
|
del self.cache[key]
|
||||||
|
|
||||||
|
def __delitem__(self, key: str) -> None:
|
||||||
|
if isinstance(key, str):
|
||||||
|
del self.primary[key]
|
||||||
|
elif isinstance(key, tuple):
|
||||||
|
del self.secondary[key]
|
||||||
|
|
||||||
|
if key in self.cache:
|
||||||
|
del self.cache[key]
|
||||||
|
|
||||||
|
def __getitem__(self, key: str) -> 'Pattern':
|
||||||
|
if self.enable_cache and key in self.cache:
|
||||||
|
logger.debug(f'found {key} in cache')
|
||||||
|
return self.cache[key]
|
||||||
|
|
||||||
|
logger.debug(f'loading {key}')
|
||||||
|
pg = self.primary[key]
|
||||||
|
pat = pg.gen()
|
||||||
|
self.resolve_subpatterns(pat, pg.tag)
|
||||||
|
self.cache[key] = pat
|
||||||
|
return pat
|
||||||
|
|
||||||
|
def get_primary(self, key: str) -> 'Pattern':
|
||||||
|
return self[key]
|
||||||
|
|
||||||
|
def get_secondary(self, key: str, tag: str) -> 'Pattern':
|
||||||
|
logger.debug(f'get_secondary({key}, {tag})')
|
||||||
|
key2 = (key, tag)
|
||||||
|
if self.enable_cache and key2 in self.cache:
|
||||||
|
return self.cache[key2]
|
||||||
|
|
||||||
|
pg = self.secondary[key2]
|
||||||
|
pat = pg.gen()
|
||||||
|
self.resolve_subpatterns(pat, pg.tag)
|
||||||
|
self.cache[key2] = pat
|
||||||
|
return pat
|
||||||
|
|
||||||
|
def resolve_subpatterns(self, pat: 'Pattern', tag: str) -> 'Pattern':
|
||||||
|
logger.debug(f'Resolving subpatterns in {pat.name}')
|
||||||
|
for sp in pat.subpatterns:
|
||||||
|
if sp.pattern is not None:
|
||||||
|
continue
|
||||||
|
|
||||||
|
key = sp.identifier[0]
|
||||||
|
if key in self.primary:
|
||||||
|
sp.pattern = self[key]
|
||||||
|
continue
|
||||||
|
|
||||||
|
if (key, tag) in self.secondary:
|
||||||
|
sp.pattern = self.get_secondary(key, tag)
|
||||||
|
continue
|
||||||
|
|
||||||
|
raise LibraryError(f'Broken reference to {key} (tag {tag})')
|
||||||
|
return pat
|
||||||
|
|
||||||
|
def __repr__(self) -> str:
|
||||||
|
return '<Library with keys ' + repr(list(self.primary.keys())) + '>'
|
||||||
|
|
||||||
|
def set_const(self, key: str, tag: Any, const: 'Pattern', secondary: bool = False) -> None:
|
||||||
|
"""
|
||||||
|
Convenience function to avoid having to manually wrap
|
||||||
|
constant values into callables.
|
||||||
|
|
||||||
|
Args:
|
||||||
|
key: Lookup key, usually the cell/pattern name
|
||||||
|
tag: Unique tag for the source, used to disambiguate secondary patterns
|
||||||
|
const: Pattern object to return
|
||||||
|
secondary: If True, this pattern is not accessible for normal lookup, and is
|
||||||
|
only used as a sub-component of other patterns if no non-secondary
|
||||||
|
equivalent is available.
|
||||||
|
"""
|
||||||
|
pg = PatternGenerator(tag=tag, gen=lambda: const)
|
||||||
|
if secondary:
|
||||||
|
self.secondary[(key, tag)] = pg
|
||||||
|
else:
|
||||||
|
self.primary[key] = pg
|
||||||
|
|
||||||
|
def set_value(self, key: str, tag: str, value: Callable[[], 'Pattern'], secondary: bool = False) -> None:
|
||||||
|
"""
|
||||||
|
Convenience function to automatically build a PatternGenerator.
|
||||||
|
|
||||||
|
Args:
|
||||||
|
key: Lookup key, usually the cell/pattern name
|
||||||
|
tag: Unique tag for the source, used to disambiguate secondary patterns
|
||||||
|
value: Callable which takes no arguments and generates the `Pattern` object
|
||||||
|
secondary: If True, this pattern is not accessible for normal lookup, and is
|
||||||
|
only used as a sub-component of other patterns if no non-secondary
|
||||||
|
equivalent is available.
|
||||||
|
"""
|
||||||
|
pg = PatternGenerator(tag=tag, gen=value)
|
||||||
|
if secondary:
|
||||||
|
self.secondary[(key, tag)] = pg
|
||||||
|
else:
|
||||||
|
self.primary[key] = pg
|
||||||
|
|
||||||
|
def precache(self) -> 'Library':
|
||||||
|
"""
|
||||||
|
Force all patterns into the cache
|
||||||
|
|
||||||
|
Returns:
|
||||||
|
self
|
||||||
|
"""
|
||||||
|
for key in self.primary:
|
||||||
|
_ = self.get_primary(key)
|
||||||
|
for key2 in self.secondary:
|
||||||
|
_ = self.get_secondary(key2)
|
||||||
|
return self
|
||||||
|
|
||||||
|
def add(self, other: 'Library') -> 'Library':
|
||||||
|
"""
|
||||||
|
Add keys from another library into this one.
|
||||||
|
|
||||||
|
There must be no conflicting keys.
|
||||||
|
|
||||||
|
Args:
|
||||||
|
other: The library to insert keys from
|
||||||
|
|
||||||
|
Returns:
|
||||||
|
self
|
||||||
|
"""
|
||||||
|
conflicts = [key for key in other.primary
|
||||||
|
if key in self.primary]
|
||||||
|
if conflicts:
|
||||||
|
raise LibraryError('Duplicate keys encountered in library merge: ' + pformat(conflicts))
|
||||||
|
|
||||||
|
conflicts2 = [key2 for key2 in other.secondary
|
||||||
|
if key2 in self.secondary]
|
||||||
|
if conflicts2:
|
||||||
|
raise LibraryError('Duplicate secondary keys encountered in library merge: ' + pformat(conflicts2))
|
||||||
|
|
||||||
|
self.primary.update(other.primary)
|
||||||
|
self.secondary.update(other.secondary)
|
||||||
|
self.cache.update(other.cache)
|
||||||
|
return self
|
||||||
|
|
||||||
|
def demote(self, key: str) -> None:
|
||||||
|
"""
|
||||||
|
Turn a primary pattern into a secondary one.
|
||||||
|
It will no longer be accessible through [] indexing and will only be used to
|
||||||
|
when referenced by other patterns from the same source, and only if no primary
|
||||||
|
pattern with the same name exists.
|
||||||
|
|
||||||
|
Args:
|
||||||
|
key: Lookup key, usually the cell/pattern name
|
||||||
|
"""
|
||||||
|
pg = self.primary[key]
|
||||||
|
key2 = (key, pg.tag)
|
||||||
|
self.secondary[key2] = pg
|
||||||
|
if key in self.cache:
|
||||||
|
self.cache[key2] = self.cache[key]
|
||||||
|
del self[key]
|
||||||
|
|
||||||
|
def promote(self, key: str, tag: str) -> None:
|
||||||
|
"""
|
||||||
|
Turn a secondary pattern into a primary one.
|
||||||
|
It will become accessible through [] indexing and will be used to satisfy any
|
||||||
|
reference to a pattern with its key, regardless of tag.
|
||||||
|
|
||||||
|
Args:
|
||||||
|
key: Lookup key, usually the cell/pattern name
|
||||||
|
tag: Unique tag for identifying the pattern's source, used to disambiguate
|
||||||
|
secondary patterns
|
||||||
|
"""
|
||||||
|
if key in self.primary:
|
||||||
|
raise LibraryError(f'Promoting ({key}, {tag}), but {key} already exists in primary!')
|
||||||
|
|
||||||
|
key2 = (key, tag)
|
||||||
|
pg = self.secondary[key2]
|
||||||
|
self.primary[key] = pg
|
||||||
|
if key2 in self.cache:
|
||||||
|
self.cache[key] = self.cache[key2]
|
||||||
|
del self.secondary[key2]
|
||||||
|
del self.cache[key2]
|
||||||
|
|
||||||
|
|
||||||
|
r"""
|
||||||
|
# Add a filter for names which aren't added
|
||||||
|
|
||||||
|
- Registration:
|
||||||
|
- scanned files (tag=filename, gen_fn[stream, {name: pos}])
|
||||||
|
- generator functions (tag='fn?', gen_fn[params])
|
||||||
|
- merge decision function (based on tag and cell name, can be "neither") ??? neither=keep both, load using same tag!
|
||||||
|
- Load process:
|
||||||
|
- file:
|
||||||
|
- read single cell
|
||||||
|
- check subpat identifiers, and load stuff recursively based on those. If not present, load from same file??
|
||||||
|
- function:
|
||||||
|
- generate cell
|
||||||
|
- traverse and check if we should load any subcells from elsewhere. replace if so.
|
||||||
|
* should fn generate subcells at all, or register those separately and have us control flow? maybe ask us and generate itself if not present?
|
||||||
|
|
||||||
|
- Scan all GDS files, save name -> (file, position). Keep the streams handy.
|
||||||
|
- Merge all names. This requires subcell merge because we don't know hierarchy.
|
||||||
|
- possibly include a "neither" option during merge, to deal with subcells. Means: just use parent's file.
|
||||||
|
"""
|
@ -0,0 +1,48 @@
|
|||||||
|
from typing import Callable, TypeVar, Generic
|
||||||
|
from functools import lru_cache
|
||||||
|
|
||||||
|
|
||||||
|
Key = TypeVar('Key')
|
||||||
|
Value = TypeVar('Value')
|
||||||
|
|
||||||
|
|
||||||
|
class DeferredDict(dict, Generic[Key, Value]):
|
||||||
|
"""
|
||||||
|
This is a modified `dict` which is used to defer loading/generating
|
||||||
|
values until they are accessed.
|
||||||
|
|
||||||
|
```
|
||||||
|
bignum = my_slow_function() # slow function call, would like to defer this
|
||||||
|
numbers = Library()
|
||||||
|
numbers['big'] = my_slow_function # no slow function call here
|
||||||
|
assert(bignum == numbers['big']) # first access is slow (function called)
|
||||||
|
assert(bignum == numbers['big']) # second access is fast (result is cached)
|
||||||
|
```
|
||||||
|
|
||||||
|
The `set_const` method is provided for convenience;
|
||||||
|
`numbers['a'] = lambda: 10` is equivalent to `numbers.set_const('a', 10)`.
|
||||||
|
"""
|
||||||
|
def __init__(self, *args, **kwargs) -> None:
|
||||||
|
dict.__init__(self)
|
||||||
|
self.update(*args, **kwargs)
|
||||||
|
|
||||||
|
def __setitem__(self, key: Key, value: Callable[[], Value]) -> None:
|
||||||
|
cached_fn = lru_cache(maxsize=1)(value)
|
||||||
|
dict.__setitem__(self, key, cached_fn)
|
||||||
|
|
||||||
|
def __getitem__(self, key: Key) -> Value:
|
||||||
|
return dict.__getitem__(self, key)()
|
||||||
|
|
||||||
|
def update(self, *args, **kwargs) -> None:
|
||||||
|
for k, v in dict(*args, **kwargs).items():
|
||||||
|
self[k] = v
|
||||||
|
|
||||||
|
def __repr__(self) -> str:
|
||||||
|
return '<Library with keys ' + repr(set(self.keys())) + '>'
|
||||||
|
|
||||||
|
def set_const(self, key: Key, value: Value) -> None:
|
||||||
|
"""
|
||||||
|
Convenience function to avoid having to manually wrap
|
||||||
|
constant values into callables.
|
||||||
|
"""
|
||||||
|
self[key] = lambda: value
|
Loading…
Reference in New Issue