Datasets:
File size: 3,513 Bytes
ef5b92c |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 |
from __future__ import annotations
import csv
from pathlib import Path
import threading
from typing import Any, Protocol, runtime_checkable
@runtime_checkable
class Hashable(Protocol):
def to_dict(self) -> dict: ...
def column_names(self) -> list[str]: ...
def get(self, key: str) -> str | None: ...
def __getitem__(self, key: str) -> str: ...
def __setitem__(self, key: str, value: Any) -> None: ...
def __contains__(self, key: str) -> bool: ...
@classmethod
def from_dict(cls, data: dict) -> Hashable: ...
class MetadataItem(Hashable):
def __init__(self, **kwargs) -> None:
self.data = kwargs
def get(self, key: str) -> str | None:
return self.data.get(key, None)
def to_dict(self) -> dict:
return self.data
def column_names(self) -> list[str]:
return list(self.data.keys())
@classmethod
def from_dict(cls, data: dict) -> MetadataItem:
return cls(**data)
def __getitem__(self, key: str) -> str:
return self.data[key]
def __setitem__(self, key: str, value: str | float) -> None:
self.data[key] = value
def __contains__(self, key: str) -> bool:
return key in self.data
class LockedMetadata:
def __init__(
self,
key_field: str,
existing: list[Hashable] | None = None,
) -> None:
self.key_field = key_field
self.lock = threading.Lock()
existing = existing or []
self.metadata: dict[str, Hashable] = {}
for item in existing:
if not isinstance(item, Hashable):
raise TypeError(f"Item must be of type {Hashable.__name__}, got {type(item).__name__}.")
key = item.get(self.key_field)
if key is None:
raise ValueError(f"Item must have a '{self.key_field}' field.")
self.metadata[key] = item
def add(self, item: Hashable) -> Hashable | None:
replaced: Hashable | None = None
with self.lock:
key = item.get(self.key_field)
if key is None:
raise ValueError(f"Item must have a '{self.key_field}' field.")
if key in self.metadata:
replaced = self.metadata[key]
self.metadata[key] = item
return replaced
def get(self, key: str) -> Hashable | None:
with self.lock:
return self.metadata.get(key, None)
def __contains__(self, item: str) -> bool:
with self.lock:
return item in self.metadata
def __iter__(self):
with self.lock:
return iter(self.metadata.values())
def save(self, file: Path) -> None:
with self.lock:
items = list(self.metadata.values())
if not items:
return
item = items[0]
with open(file, 'w', newline='', encoding='utf-8') as f:
writer = csv.DictWriter(f, fieldnames=item.column_names())
writer.writeheader()
writer.writerows([item.to_dict() for item in items])
@classmethod
def load(
cls,
file: Path,
key_field: str,
item_type: type[Hashable] = MetadataItem,
) -> LockedMetadata:
items = []
with open(file, 'r', newline='', encoding='utf-8') as f:
reader = csv.DictReader(f)
for row in reader:
items.append(item_type.from_dict(row))
return cls(existing=items, key_field=key_field)
|