clean entry

src/ytdl_sub/downloaders/info_json/info_json_downloader.py

@@ -109,10 +109,7 @@ class InfoJsonDownloader(SourcePlugin[InfoJsonDownloaderOptions]):
                 prior_variables = entry.kwargs(YTDL_SUB_ENTRY_VARIABLES_KWARG_KEY)
                 del entry._kwargs[YTDL_SUB_ENTRY_VARIABLES_KWARG_KEY]
 
-            entry.initialize_script(
+            entry.initialize_script(self.overrides).add(
-                override_variables=self.overrides.dict_with_format_strings,
-                unresolvable=self.overrides.unresolvable,
-            ).add(
                 {
                     inj.variable_name: prior_variables.get(
                         inj.variable_name,

src/ytdl_sub/downloaders/url/downloader.py

@@ -459,10 +459,7 @@ class MultiUrlDownloader(SourcePlugin[MultiUrlValidator]):
             for entry in self._iterate_entries(
                 url_validator=collection_url, parents=parents, orphans=orphan_entries
             ):
-                entry.initialize_script(
+                entry.initialize_script(self.overrides).add(
-                    override_variables=self.overrides.dict_with_format_strings,
-                    unresolvable=self.overrides.unresolvable,
-                ).add(
                     {
                         v.ytdl_sub_input_url.variable_name: self.overrides.apply_formatter(
                             collection_url.url

src/ytdl_sub/entries/entry.py

@@ -30,28 +30,20 @@ class Entry(BaseEntry, Scriptable):
         BaseEntry.__init__(self, entry_dict=entry_dict, working_directory=working_directory)
         Scriptable.__init__(self)
 
-    def initialize_script(
+    def _add_entry_kwargs_to_script(self) -> None:
-        self, override_variables: Dict[str, str], unresolvable: Set[str]
+        # Add entry metadata, but avoid the `.add()` helper since it also adds sanitized
-    ) -> "Entry":
+        self.unresolvable.remove(VARIABLES.entry_metadata.variable_name)
+        self.script.add({VARIABLES.entry_metadata.variable_name: f"{{{json.dumps(self._kwargs)}}}"})
+        self.update_script()
+
+    def initialize_script(self, other: Optional[Scriptable] = None) -> "Entry":
         # TODO: CLEAN THIS SHIT UP
         # Overrides contains added variables that are unresolvable, add them here
-        self.unresolvable |= unresolvable
+        if other:
+            self.script = copy.deepcopy(other.script)
+            self.unresolvable = copy.deepcopy(other.unresolvable)
 
-        # Remove the entry variable
+        self._add_entry_kwargs_to_script()
-        self.unresolvable.remove(VARIABLES.entry_metadata.variable_name)
-
-        # Add entry metadata, but avoid the `.add()` helper since it also adds sanitized
-        self.script.add({VARIABLES.entry_metadata.variable_name: f"{{{json.dumps(self._kwargs)}}}"})
-        self.script.add(
-            {
-                unresolved: f"{{%throw('Variable {unresolved} has not been resolved yet')}}"
-                for unresolved in self.unresolvable
-            }
-        )
-
-        # use .add here to get sanitized
-        self.add(override_variables)
-        self.update_script()
         return self
 
     def get(self, variable: Variable, expected_type: Type[TType]) -> TType:

src/ytdl_sub/entries/entry_parent.py

@@ -60,7 +60,7 @@ class EntryParent(BaseEntry):
             parents = [self]
 
         kwargs_to_add: Dict[str, Any] = {
-            v.sibling_entry_metadata.metadata_key: self._sibling_entry_metadata()
+            v.sibling_metadata.metadata_key: self._sibling_entry_metadata()
         }
         if len(parents) >= 1:
             kwargs_to_add[v.playlist_metadata.metadata_key] = parents[-1]._kwargs

src/ytdl_sub/entries/script/variable_definitions.py

@@ -56,8 +56,8 @@ class _Variables:
         return RelativeMetadata("source_metadata", metadata_key="source_metadata")
 
     @property
-    def sibling_entry_metadata(self) -> SiblingMetadata:
+    def sibling_metadata(self) -> SiblingMetadata:
-        return SiblingMetadata("sibling_entry_metadata", metadata_key="sibling_entry_metadata")
+        return SiblingMetadata("sibling_metadata", metadata_key="sibling_metadata")
 
     @property
     def uid(self) -> MetadataVariable:

src/ytdl_sub/entries/script/variable_scripts.py

@@ -118,7 +118,7 @@ ENTRY_HARDCODED_VARIABLES: Dict[Variable, str] = {
 ENTRY_RELATIVE_VARIABLES: Dict[MetadataVariable, str] = {
     v.playlist_metadata: entry_get(v.playlist_metadata, {}),
     v.source_metadata: entry_get(v.source_metadata, {}),
-    v.sibling_entry_metadata: entry_get(v.sibling_entry_metadata, "{ [] }"),
+    v.sibling_metadata: entry_get(v.sibling_metadata, []),
 }
 
 ENTRY_REQUIRED_VARIABLES: Dict[MetadataVariable, str] = {
@@ -279,6 +279,18 @@ mergedeep.merge(
 VARIABLE_SCRIPTS: Dict[str, str] = {
     var.variable_name: script for var, script in _VARIABLE_SCRIPTS.items()
 }
-UNRESOLVED_VARIABLES: Set[str] = {var.variable_name for var in ENTRY_INJECTED_VARIABLES}
+
+
+def _keys(*variables: Dict[Variable, str]) -> Set[str]:
+    keys: Set[str] = set()
+    for variable_set in variables:
+        keys.update(set(var.variable_name for var in variable_set.keys()))
+    return keys
+
+
+UNRESOLVED_VARIABLES: Set[str] = _keys(
+    ENTRY_EMPTY_METADATA,
+    ENTRY_INJECTED_VARIABLES,
+)
 
 CustomFunctions.register()

tests/unit/entries/conftest.py

@@ -178,7 +178,4 @@ def mock_entry_kwargs(
 
 @pytest.fixture
 def mock_entry(mock_entry_kwargs):
-    return Entry(entry_dict=mock_entry_kwargs, working_directory=".").initialize_script(
+    return Entry(entry_dict=mock_entry_kwargs, working_directory=".").initialize_script()
-        override_variables={},
-        unresolvable=set(),
-    )

tests/unit/entries/test_entry.py

@@ -7,7 +7,11 @@ from ytdl_sub.entries.script.variable_definitions import VARIABLES as v
 class TestEntry(object):
     def test_entry_to_dict(self, mock_entry, mock_entry_to_dict):
         out = mock_entry.to_dict()
-        del out["entry_metadata"]
+        del out[v.entry_metadata.variable_name]
+        del out[v.ytdl_sub_input_url.variable_name]
+        del out[v.playlist_metadata.variable_name]
+        del out[v.source_metadata.variable_name]
+        del out[v.sibling_metadata.variable_name]
         assert out == mock_entry_to_dict
 
     def test_entry_missing_kwarg(self, mock_entry):
@@ -37,9 +41,7 @@ class TestEntry(object):
     ):
 
         mock_entry_kwargs["upload_date"] = upload_date
-        entry = Entry(entry_dict=mock_entry_kwargs, working_directory=".").initialize_script(
+        entry = Entry(entry_dict=mock_entry_kwargs, working_directory=".").initialize_script()
-            override_variables={}, unresolvable=set()
-        )
         assert entry.get_int(v.upload_year_truncated_reversed) == year_rev
         assert entry.get_int(v.upload_month_reversed) == month_rev
         assert entry.get_int(v.upload_day_reversed) == day_rev
@@ -57,9 +59,7 @@ class TestEntry(object):
         self, mock_entry_kwargs, upload_date, day_year, day_year_rev, day_year_pad, day_year_rev_pad
     ):
         mock_entry_kwargs["upload_date"] = upload_date
-        entry = Entry(entry_dict=mock_entry_kwargs, working_directory=".").initialize_script(
+        entry = Entry(entry_dict=mock_entry_kwargs, working_directory=".").initialize_script()
-            override_variables={}, unresolvable=set()
-        )
 
         assert entry.get_int(v.upload_day_of_year) == day_year
         assert entry.get_int(v.upload_day_of_year_reversed) == day_year_rev