light-ass 0.1.0__tar.gz

light_ass-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ming
+
+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.

light_ass-0.1.0/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.2
+Name: light-ass
+Version: 0.1.0
+Summary: A lightweight library for handling ASS subtitles
+Author-email: Oborozuki <oborozuk1@qq.com>
+License: MIT License
+Project-URL: Homepage, https://github.com/oborozuk1/light-ass
+Project-URL: Repository, https://github.com/oborozuk1/light-ass.git
+Project-URL: Bug Tracker, https://github.com/oborozuk1/light-ass/issues
+Keywords: subtitle,ass
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Multimedia :: Video
+Classifier: Development Status :: 3 - Alpha
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# light-ass
+A lightweight library for handling Advanced SubStation Alpha (ASS) subtitles.
+
+## Features
+- Parse ASS subtitles effortlessly
+- Check the validity of field types
+- Parse ASS override tags (partial)
+
+## Installation
+```
+pip install light-ass
+```
+
+## Usage
+```python
+import light_ass
+
+document = light_ass.load("example.ass")
+print(document.info)
+print(document.styles)
+print(document.events)
+```
+
+## TODO
+- Support for more sections
+- More methods for ASS shapes
+- ASS minifier
+- Support for VSFilterMod tags
+
+## License
+MIT License

light_ass-0.1.0/README.md

@@ -0,0 +1,31 @@
+# light-ass
+A lightweight library for handling Advanced SubStation Alpha (ASS) subtitles.
+
+## Features
+- Parse ASS subtitles effortlessly
+- Check the validity of field types
+- Parse ASS override tags (partial)
+
+## Installation
+```
+pip install light-ass
+```
+
+## Usage
+```python
+import light_ass
+
+document = light_ass.load("example.ass")
+print(document.info)
+print(document.styles)
+print(document.events)
+```
+
+## TODO
+- Support for more sections
+- More methods for ASS shapes
+- ASS minifier
+- Support for VSFilterMod tags
+
+## License
+MIT License

light_ass-0.1.0/light_ass/__init__.py

@@ -0,0 +1,8 @@
+from . import tag_parser, subtitle, events, styles, script_info
+from .subtitle import *
+
+__all__ = [
+    "load",
+    "from_string",
+    "Subtitle",
+]

light_ass-0.1.0/light_ass/constants.py

@@ -0,0 +1,24 @@
+import re
+
+
+class AssSectionHeader:
+    SCRIPT_INFO = "Script Info"
+    ASS_STYLE = "V4+ Styles"
+    EVENTS = "Events"
+    # AEGISUB_PROJECT = "Aegisub Project Garbage"
+    # AEGISUB_EXTRADATA = "Aegisub Extradata"
+    # FONTS = "Fonts"
+    # GRAPHICS = "Graphics"
+
+
+DEFAULT_STYLES_FORMAT = (
+    "Name", "Fontname", "Fontsize", "PrimaryColour", "SecondaryColour", "OutlineColour", "BackColour",
+    "Bold", "Italic", "Underline", "StrikeOut", "ScaleX", "ScaleY", "Spacing", "Angle", "BorderStyle",
+    "Outline", "Shadow", "Alignment", "MarginL", "MarginR", "MarginV", "Encoding",
+)
+
+DEFAULT_EVENTS_FORMAT = ("Layer", "Start", "End", "Style", "Name", "MarginL", "MarginR", "MarginV", "Effect", "Text")
+
+SECTION_PATTERN = re.compile(r"^\s*\[([^]]+)]\s*")
+
+OVERRIDE_BLOCK_PATTERN = re.compile(r"(?<!\\){([^}]*)}")

light_ass-0.1.0/light_ass/events.py

@@ -0,0 +1,127 @@
+from collections.abc import Sequence
+
+from .ass_types.ass_time import AssTime
+from .constants import OVERRIDE_BLOCK_PATTERN
+from .tag_parser import Tag, parse_tags
+from .utils import validate_value
+
+
+class Dialog(dict):
+    _formats = {
+        "comment": bool,
+        "layer": int,
+        "start": AssTime,
+        "end": AssTime,
+        "style": str,
+        "name": str,
+        "margin_l": int,
+        "margin_r": int,
+        "margin_v": int,
+        "effect": str,
+        "text": str,
+    }
+    _alias = {
+        "commented": "comment",
+        "start_time": "start",
+        "end_time": "end",
+        "actor": "name",
+    }
+
+    comment: bool
+    layer: int
+    start: AssTime
+    end: AssTime
+    style: str
+    name: str
+    margin_l: int
+    margin_r: int
+    margin_v: int
+    effect: str
+    text: str
+    commented: bool
+    start_time: AssTime
+    end_time: AssTime
+    actor: str
+
+    def __init__(self, **kwargs) -> None:
+        if set(kwargs.keys()) != set(self._formats.keys()):
+            raise ValueError("Keys of kwargs must equal formats")
+        super().__init__()
+        for key, value in kwargs.items():
+            self[key] = self.validate_value(key, value)
+
+    def __getattr__(self, name: str):
+        if name in self._alias:
+            name = self._alias[name]
+        if name in self._formats:
+            return self[name]
+        else:
+            raise AttributeError(f"{name} is not a valid attribute")
+
+    def __setattr__(self, name: str, value):
+        if name in self._alias:
+            name = self._alias[name]
+        if name in self._formats:
+            self[name] = Dialog.validate_value(name, value)
+        else:
+            raise AttributeError(f"{name} is not a valid attribute")
+
+    def __repr__(self) -> str:
+        return "Dialog({})".format(
+            ",".join(f"{key}={value}" for key, value in self.items())
+        )
+
+    def __str__(self) -> str:
+        dialog_line = []
+        for key, value in self.items():
+            if key == "comment":
+                continue
+            if type(value) is float:
+                value = f"{value:g}"
+            dialog_line.append(str(value))
+        return "{}: {}".format("Comment" if self.comment else "Dialogue", ",".join(dialog_line))
+
+    def shift(self, ms: int) -> None:
+        self.start += ms
+        self.end += ms
+
+    def parse_tags(self) -> list[Tag]:
+        return parse_tags(self.text)
+
+    @property
+    def text_stripped(self) -> str:
+        return OVERRIDE_BLOCK_PATTERN.sub("", self.text)
+
+    @staticmethod
+    def validate_value(key, value):
+        if key in Dialog._alias:
+            key = Dialog._alias[key]
+        try:
+            return validate_value(Dialog._formats[key], value)
+        except ValueError:
+            raise ValueError(f"Invalid value for {key}: {value}")
+
+
+class Events(list[Dialog]):
+    def pop(self, index: int | Sequence[int] = -1):
+        if isinstance(index, int):
+            index = (index,)
+        for i in sorted(index, reverse=True):
+            super().pop(i)
+
+    def shift(self, ms: int, range_: Sequence[int] | None = None):
+        """
+        Shift the start and end time of events by milliseconds.
+        :param ms: The amount of milliseconds to shift the events by.
+        :param range_: The range of events to shift. If None, all events will be shifted.
+        :return: None
+        """
+        if range_ is None:
+            range_ = range(0, len(self))
+        for i in range_:
+            self[i].shift(ms)
+
+    def sort(self, *, key = None, reverse = False):
+        if key is None:
+            key = lambda x: x.start
+        super().sort(key = key, reverse = reverse)

light_ass-0.1.0/light_ass/script_info.py

@@ -0,0 +1,97 @@
+from typing import Any, Self, Literal
+
+from .utils import validate_value
+
+ScriptInfoKeys = Literal[
+    "Title",
+    "Original Script",
+    "Original Translation",
+    "Original Editing",
+    "Original Timing",
+    "Synch Point",
+    "Script Updated By",
+    "ScriptType",
+    "Update Details",
+    "PlayResX",
+    "PlayResY",
+    "PlayDepth",
+    "ScaledBorderAndShadow",
+    "WrapStyle",
+    "YCbCr Matrix",
+    "Collisions",
+    "Timer",
+    "LayoutResX",
+    "LayoutResY",
+    # libass extensions
+    "Kerning",
+    "Language",
+]
+
+
+class ScriptInfo(dict):
+    _formats = {
+        "Title": str,
+        "Original Script": str,
+        "Original Translation": str,
+        "Original Editing": str,
+        "Original Timing": str,
+        "Synch Point": str,
+        "Script Updated By": str,
+        "ScriptType": str,
+        "Update Details": str,
+        "PlayResX": int,
+        "PlayResY": int,
+        "PlayDepth": int,
+        "ScaledBorderAndShadow": {"yes": True, "no": False},
+        "WrapStyle": (0, 1, 2, 3),
+        "YCbCr Matrix": ("None", "TV.601", "PC.601", "TV.709", "PC.709", "TV.FCC", "PC.FCC", "TV.240M", "PC.240M"),
+        "Collisions": ("Normal", "Reverse"),
+        "Timer": float,
+        "LayoutResX": int,
+        "LayoutResY": int,
+        # libass extensions
+        "Kerning": {"yes": True, "no": False},
+        "Language": str,
+    }
+
+    def __init__(self, info: Self | dict[str, Any] | None = None):
+        super().__init__()
+        if isinstance(info, dict):
+            for key, value in info.items():
+                self[key] = value
+
+    def sort(self):
+        mapping = {key: i for i, key in enumerate(self._formats.keys())}
+        new = sorted(self.items(), key=lambda x: mapping.get(x[0], 99))
+        self.clear()
+        self.update(new)
+
+    def __getitem__(self, key: ScriptInfoKeys | str):
+        return super().__getitem__(key)
+
+    def __setitem__(self, key: ScriptInfoKeys | str, value):
+        if value is None:
+            self.pop(key)
+        else:
+            super().__setitem__(key, self.validate_value(key, value))
+
+    def __repr__(self) -> str:
+        return f"ScriptInfo({super().__repr__()})"
+
+    def __str__(self) -> str:
+        infos = []
+        for key, value in self.items():
+            if isinstance(self._formats[key], dict):
+                rev_dict = {v: k for k, v in self._formats[key].items()}
+                value = rev_dict[value]
+            infos.append(f"{key}: {value}")
+        return "\n".join(infos)
+
+    @staticmethod
+    def validate_value(key, value):
+        if key not in ScriptInfo._formats:
+            return value
+        try:
+            return validate_value(ScriptInfo._formats[key], value)
+        except ValueError:
+            raise ValueError(f"Invalid value for {key}: {value}")

light_ass-0.1.0/light_ass/styles.py

@@ -0,0 +1,191 @@
+from collections.abc import Iterable
+from typing import Self, Literal
+
+from .ass_types.ass_color import AssColor
+from .utils import validate_value
+
+StyleKeys = Literal[
+    "name",
+    "fontname",
+    "fontsize",
+    "primary_colour",
+    "secondary_colour",
+    "outline_colour",
+    "back_colour",
+    "bold",
+    "italic",
+    "underline",
+    "strike_out",
+    "scale_x",
+    "scale_y",
+    "spacing",
+    "angle",
+    "border_style",
+    "outline",
+    "shadow",
+    "alignment",
+    "margin_l",
+    "margin_r",
+    "margin_v",
+    "encoding",
+    "color1",
+    "color2",
+    "color3",
+    "color4",
+    "align",
+]
+
+
+class Style(dict):
+    _formats = {
+        "name": str,
+        "fontname": str,
+        "fontsize": float,
+        "primary_colour": AssColor,
+        "secondary_colour": AssColor,
+        "outline_colour": AssColor,
+        "back_colour": AssColor,
+        "bold": {"0": False, "-1": True},
+        "italic": {"0": False, "-1": True},
+        "underline": {"0": False, "-1": True},
+        "strike_out": {"0": False, "-1": True},
+        "scale_x": float,
+        "scale_y": float,
+        "spacing": float,
+        "angle": float,
+        "border_style": (1, 3, 4),  # 4 for libass
+        "outline": float,
+        "shadow": float,
+        "alignment": (1, 2, 3, 4, 5, 6, 7, 8, 9),
+        "margin_l": int,
+        "margin_r": int,
+        "margin_v": int,
+        "encoding": int,
+    }
+    _alias = {
+        "color1": "primary_colour",
+        "color2": "secondary_colour",
+        "color3": "outline_colour",
+        "color4": "back_colour",
+        "align": "alignment",
+    }
+
+    name: str
+    fontname: str
+    fontsize: float
+    primary_colour: AssColor
+    secondary_colour: AssColor
+    outline_colour: AssColor
+    back_colour: AssColor
+    bold: bool
+    italic: bool
+    underline: bool
+    strike_out: bool
+    scale_x: float
+    scale_y: float
+    spacing: float
+    angle: float
+    border_style: int
+    outline: float
+    shadow: float
+    alignment: int
+    margin_l: int
+    margin_r: int
+    margin_v: int
+    encoding: int
+
+    color1: AssColor
+    color2: AssColor
+    color3: AssColor
+    color4: AssColor
+    align: int
+
+    def __init__(self, from_: dict | Iterable | None = None, **kwargs):
+        if from_ is not None:
+            kwargs = dict(from_)
+        if set(kwargs.keys()) != set(self._formats.keys()):
+            raise ValueError("Keys of kwargs must equal formats")
+        super().__init__({k: self.validate_value(k, v) for k, v in kwargs.items() if k != "name"})
+        self._name = kwargs["name"]
+
+    @property
+    def name(self):
+        return self._name
+
+    def __getitem__(self, key: StyleKeys | str):
+        if key in self._alias:
+            key = self._alias[key]
+        return super().__getitem__(key)
+
+    def __setitem__(self, key: StyleKeys | str, value):
+        if key in self._alias:
+            key = self._alias[key]
+        if key in self._formats:
+            super().__setitem__(key, self.validate_value(key, value))
+        else:
+            raise KeyError(f"{key} is not a valid key")
+
+    def __getattr__(self, key: str):
+        return self[key]
+
+    def __setattr__(self, key: str, value) -> None:
+        if key.startswith("_"):
+            super().__setattr__(key, value)
+        else:
+            self[key] = value
+
+    def __repr__(self) -> str:
+        return "Style({})".format(",".join(f"{key}={value}" for key, value in self.items()))
+
+    def __str__(self) -> str:
+        style_line = [self.name]
+        for key, value in self.items():
+            if isinstance(self._formats[key], dict):
+                rev_dict = {v: k for k, v in self._formats[key].items()}
+                value = rev_dict[value]
+            elif type(value) is float:
+                value = "{:g}".format(value)
+            style_line.append(str(value))
+        return f"Style: {','.join(style_line)}"
+
+    @staticmethod
+    def validate_value(key, value):
+        if key in Style._alias:
+            key = Style._alias[key]
+        try:
+            return validate_value(Style._formats[key], value)
+        except ValueError:
+            raise ValueError(f"Invalid value for {key}: {value}")
+
+
+class Styles(dict[str, Style]):
+    def __init__(self, from_: Self | dict[str, Style] | None = None):
+        if from_ is None:
+            super().__init__()
+        else:
+            super().__init__(from_)
+
+    def __setitem__(self, key, value):
+        if isinstance(value, Style):
+            value._name = key
+            super().__setitem__(key, value)
+        else:
+            raise TypeError("value must be a Style")
+
+    def __repr__(self):
+        return f"Styles({", ".join(self.keys())})"
+
+    def __str__(self):
+        return "\n".join((str(style) for style in self.values()))
+
+    def set(self, style: Style):
+        self[style.name] = style
+
+    def rename(self, old_name: str, new_name: str):
+        if old_name not in self:
+            raise KeyError(f"{old_name} is not a valid style name")
+        if new_name in self:
+            raise KeyError(f"{new_name} is already a style name")
+        style = self.pop(old_name)
+        style._name = new_name
+        self[new_name] = style