lightshark-parser 1.0.0__py3-none-any.whl

lightshark_parser/__init__.py

@@ -0,0 +1,13 @@
+"""
+LightShark Parser - A Python library for parsing LightShark show files.
+"""
+
+__version__ = "1.0.0"
+
+from lightshark_parser.classes import Lightshow
+from lightshark_parser.parsers.file_parser import parse_file_bytes, parse_lshw
+from lightshark_parser.parsers.parse_dict import parse_dict_to_lightshow
+from lightshark_parser.utils.logger import logger
+
+
+__all__ = ["parse_file_bytes", "parse_lshw", "parse_dict_to_lightshow", "Lightshow", "logger"]

lightshark_parser/__main__.py

@@ -0,0 +1,6 @@
+try:
+    from main import main
+except (NameError, FileNotFoundError, ModuleNotFoundError):
+    from lightshark_parser.main import main
+
+main()

lightshark_parser/classes/__init__.py

@@ -0,0 +1,28 @@
+"""Lightshow Parser - Core data models for Lightshow files."""
+
+from .lightshow import Lightshow
+from .fileinfo import Version, FileInfo
+from .model import Model, ModelPalette, ModelValue, ModelValueStep, ModelHardware, Macro, MacroStep
+from .patch import Patch
+from .group import Group
+from .user_palette import UserPalette
+from .cue import Cue, Order
+from .cuelist import Cuelist, CuelistElement
+from .playback import Playback
+from .fx import FX, FXLayer, FXLayerStep, FXPalette
+from .general import Config, General
+from .action import Action
+
+__all__ = [
+    'Lightshow',
+    'Version', 'FileInfo',
+    'Model', 'ModelPalette', 'ModelValue', 'ModelValueStep', 'ModelHardware', 'Macro', 'MacroStep',
+    'Patch',
+    'Group',
+    'UserPalette',
+    'Cue', 'Order', 'Action',
+    'Cuelist', 'CuelistElement',
+    'Playback',
+    'FX', 'FXLayer', 'FXLayerStep', 'FXPalette',
+    'Config', 'General',
+]

lightshark_parser/classes/action.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+from typing import Dict, Any
+
+class Action:
+    # NOT IMPLEMENTED #
+    def __init__():
+        pass
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Action":
+        return cls()

lightshark_parser/classes/cue.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+from typing import Dict, List, Any, Optional, Union
+from lightshark_parser.serialisers.attribute_serialisers import *
+from lightshark_parser.classes.fx import FX
+from lightshark_parser.classes.order import Order
+from lightshark_parser.classes.action import Action
+from lightshark_parser.utils.logger import logger
+
+class Cue:
+    """
+
+
+    NOTE: Actions not implemented yet
+    """
+
+    def __init__(
+        self,
+        fx_palette: Optional[int|str] = None,
+        cue_id: Optional[int] = None,
+        description: Optional[str] = None,
+        visual_id: Optional[int] = None,
+        fxs: Optional[List["FX"]] = None,
+        fxs_channels: Optional[List[List[Union[int, str]]]] = None,
+        orders: Optional[dict[int, dict[int, Order]]] = None,
+        actions: Optional[List["Action"]] = None,
+        name: Optional[str] = None,
+    ) -> None:
+        self.fx_palette: int|str = fx_palette
+        self.cue_id: int = cue_id
+        self.description: str = description
+        self.visual_id: int = visual_id
+        self.fxs: List[FX] = fxs if fxs is not None else []
+        self.fxs_channels: List[dict] = fxs_channels
+        self.orders: dict[int, dict[int, Order]] = orders
+        self.actions: List[Action] = actions
+        self.name: str = name
+
+
+
+    def __repr__(self):
+        return (
+            f"Cue(fx_palette={self.fx_palette!r}, cue_id={self.cue_id!r}, "
+            f"description={self.description!r}, visual_id={self.visual_id!r}, "
+            f"fxs={self.fxs!r}, fxs_channels={self.fxs_channels!r}, "
+            f"orders={self.orders!r}, actions={self.actions!r}, name={self.name!r})"
+        )
+
+    def to_dict(self) -> dict:
+        fxs_list = []
+        if self.fxs is not None:
+            for fx in self.fxs:
+                if hasattr(fx, "to_dict"):
+                    fxs_list.append(fx.to_dict())
+                elif hasattr(fx, "__dict__"):
+                    fxs_list.append(fx.__dict__)
+                else:
+                    fxs_list.append(fx)
+
+        orders_dict = {}
+        if self.orders is not None:
+            orders_dict = {
+                patch_id: {
+                    ftype: order.to_dict() if hasattr(order, "to_dict") else order
+                    for ftype, order in ftype_orders.items()
+                }
+                for patch_id, ftype_orders in self.orders.items()
+            }
+
+        return {
+            "fx_palette": self.fx_palette,
+            "cue_id": self.cue_id,
+            "description": self.description,
+            "visual_id": self.visual_id,
+            "actions": self.actions,
+            "fxs": fxs_list,  # Always return the list (empty if no fxs)
+            "fxs_channels": self.fxs_channels,
+            "orders": orders_dict,
+            "name": self.name,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Cue":
+        if data is None:
+            return None
+        fxs = [FX.from_dict(fx) for fx in data.get("fxs", [])] if data.get("fxs") else []
+        orders_data = data.get("orders", {})
+        orders = {
+            int(patch_id): {
+                int(ftype): Order.from_dict(order_data)
+                for ftype, order_data in ftype_orders.items()
+            }
+            for patch_id, ftype_orders in orders_data.items()
+        }
+        actions = [Action.from_dict(action) for action in data.get("actions", [])] if data.get("actions") else None
+        return cls(
+            fx_palette=data.get("fx_palette"),
+            cue_id=data.get("cue_id"),
+            description=data.get("description"),
+            visual_id=data.get("visual_id"),
+            fxs=fxs,
+            fxs_channels=data.get("fxs_channels"),
+            orders=orders,
+            actions=actions,
+            name=data.get("name"),
+        )
+
+
+    def to_bytes(self) -> bytes:
+        logger.debug(f"Starting serialization of Cue object {self.name} (id: {self.cue_id})")
+        bytestr = bytearray(serialise_section_header("cue"))
+        content = bytearray()
+        num_attr = 0
+        
+        num_attrs = ["cue_id", "visual_id"]
+        string_attrs = ["description", "name"]
+        
+        for attr_name, attr_value in self.__dict__.items():
+            if attr_value is not None:
+                content.extend(serialise_attr_name(attr_name))
+                num_attr += 1
+                logger.debug("Serialising attribute: " + attr_name)
+                if attr_name == "fx_palette":
+                    if attr_value == "N/A":
+                        content.extend(b'\xFF')
+                    else:
+                        content.extend(serialise_num_value(attr_value, cc_check=True))
+                elif attr_name in num_attrs:
+                    content.extend(serialise_num_value(attr_value, cc_check=True))
+                elif attr_name in string_attrs:
+                    content.extend(serialise_str_value(attr_value))
+                elif attr_name == 'fxs_channels':
+                    num_lists = len(attr_value)
+                    content.extend(serialise_objlist_len(num_lists))
+                    logger.debug(f"value: {attr_value}")
+                    logger.debug(f"Number of FX channel instances: {num_lists}")
+
+                    for fx_channel in attr_value:
+                        logger.debug(f"channel: {fx_channel}")
+                        list_content = bytearray()
+                        list_len = sum(1 for value in fx_channel if not isinstance(value, str))
+                        if list_len != 16:
+                            raise ValueError("FX channel list length should be 16 (NOTE: unconfirmed. though this error shouldn't happen either way...)")
+                        list_content.extend(serialise_objlist_len(list_len))
+                        for value in fx_channel:
+                            # \xd1 \x?? instances
+                            if isinstance(value, str):
+                                list_content.extend(bytes.fromhex(value))
+                            else:
+                                list_content.extend(serialise_num_value(value, cc_check=True))
+                        content.extend(list_content)
+
+                elif attr_name == 'fxs':
+                    num_fxs = len(attr_value)
+                    content.extend(serialise_objlist_len(num_fxs))
+                    for fx in attr_value:
+                        content.extend(fx.to_bytes())
+                elif attr_name == 'orders':
+                    num_orders = sum(len(ftype_orders) for ftype_orders in attr_value.values())
+                    content.extend(serialise_objlist_len(num_orders))
+                    for ftype_orders in attr_value.values():
+                        for order in ftype_orders.values():
+                            content.extend(order.to_bytes())
+                elif attr_name == 'actions':
+                    raise NotImplementedError("Actions not implemented yet")
+                    # num_actions = len(attr_value)
+                    # bytestr.extend(serialise_objlist_len(num_actions))
+                    # for action in attr_value:
+                    #     bytestr.extend(action.to_bytes())
+                logger.debug(f"Serialized {attr_name} for Cue {self.name} (id: {self.cue_id})")
+
+        content[0:0] = serialise_num_attr(num_attr)
+        bytestr.extend(serialise_content_length(content))
+        bytestr.extend(content)
+        logger.info("Cue object serialised")
+        logger.debug(bytestr)
+        return bytes(bytestr)

lightshark_parser/classes/cuelist.py

@@ -0,0 +1,271 @@
+from __future__ import annotations
+from typing import Dict, List, Any, Optional, Union
+from lightshark_parser.serialisers.attribute_serialisers import *
+from lightshark_parser.utils.logger import logger
+
+class Cuelist:
+
+    def __init__(
+        self,
+        ms_flash_attack: Optional[int] = 2000,
+        autoreset: Optional[bool] = True,
+        at_end_pause: Optional[bool] = False,
+        loops: Optional[int] = 1,
+        chase: Optional[bool] = False,
+        ms_chase_time: Optional[int] = 2000,
+        visual_id: Optional[int] = None,
+        bpm_chase: Optional[int] = 30000,
+        ms_flash_decay: Optional[int] = 2000,
+        pcrossfade: Optional[int] = 100000,
+        ms_fadeout: Optional[int] = 2000,
+        direction: Optional[int] = 0,
+        at_end_stop: Optional[bool] = False,
+        flash_mode: Optional[int] = 0,
+        cuelist_id: Optional[int] = None,
+        ms_fadein: Optional[int] = 2000,
+        ms_crossfade: Optional[int] = 2000,
+        no_first_fade: Optional[bool] = False,
+        name: Optional[str] = None,
+        block_fx: Optional[bool] = False,
+        cuelist_elements: Optional[Dict[int, CuelistElement]] = None,
+        ms_flash_hold: Optional[int] = 2000,
+        ms_stop_time: Optional[int] = 2000,
+    ) -> None:
+        
+        if name is None:
+            name = f"Cuelist {cuelist_id}"
+
+
+        self.ms_flash_attack: Optional[int] = ms_flash_attack
+        self.autoreset: Optional[bool] = autoreset
+        self.at_end_pause: Optional[bool] = at_end_pause
+        self.loops: Optional[int] = loops
+        self.chase: Optional[bool] = chase
+        self.ms_chase_time: Optional[int] = ms_chase_time
+        self.visual_id: Optional[int] = visual_id
+        self.bpm_chase: Optional[int] = bpm_chase
+        self.ms_flash_decay: Optional[int] = ms_flash_decay
+        self.pcrossfade: Optional[int] = pcrossfade
+        self.ms_fadeout: Optional[int] = ms_fadeout
+        self.direction: Optional[int] = direction
+        self.at_end_stop: Optional[bool] = at_end_stop
+        self.flash_mode: Optional[int] = flash_mode
+        self.cuelist_id: Optional[int] = cuelist_id
+        self.ms_fadein: Optional[int] = ms_fadein
+        self.ms_crossfade: Optional[int] = ms_crossfade
+        self.no_first_fade: Optional[bool] = no_first_fade
+        self.name: Optional[str] = name
+        self.block_fx: Optional[bool] = block_fx
+        self.cuelist_elements: Dict[int, CuelistElement] = cuelist_elements if cuelist_elements is not None else {}
+        self.ms_flash_hold: Optional[int] = ms_flash_hold
+        self.ms_stop_time: Optional[int] = ms_stop_time
+
+    def __repr__(self):
+        return (
+            f"Cuelist(ms_flash_attack={self.ms_flash_attack!r}, autoreset={self.autoreset!r}, "
+            f"at_end_pause={self.at_end_pause!r}, loops={self.loops!r}, chase={self.chase!r}, "
+            f"ms_chase_time={self.ms_chase_time!r}, visual_id={self.visual_id!r}, "
+            f"bpm_chase={self.bpm_chase!r}, ms_flash_decay={self.ms_flash_decay!r}, "
+            f"pcrossfade={self.pcrossfade!r}, ms_fadeout={self.ms_fadeout!r}, "
+            f"direction={self.direction!r}, at_end_stop={self.at_end_stop!r}, "
+            f"flash_mode={self.flash_mode!r}, cuelist_id={self.cuelist_id!r}, "
+            f"ms_fadein={self.ms_fadein!r}, ms_crossfade={self.ms_crossfade!r}, "
+            f"no_first_fade={self.no_first_fade!r}, name={self.name!r}, block_fx={self.block_fx!r}, "
+            f"cuelist_elements={self.cuelist_elements!r}, "
+            f"ms_flash_hold={self.ms_flash_hold!r}, ms_stop_time={self.ms_stop_time!r})"
+        )
+
+
+    def to_dict(self) -> dict:
+        return {
+            "ms_flash_attack": self.ms_flash_attack,
+            "autoreset": self.autoreset,
+            "at_end_pause": self.at_end_pause,
+            "loops": self.loops,
+            "chase": self.chase,
+            "ms_chase_time": self.ms_chase_time,
+            "visual_id": self.visual_id,
+            "bpm_chase": self.bpm_chase,
+            "ms_flash_decay": self.ms_flash_decay,
+            "pcrossfade": self.pcrossfade,
+            "ms_fadeout": self.ms_fadeout,
+            "direction": self.direction,
+            "at_end_stop": self.at_end_stop,
+            "flash_mode": self.flash_mode,
+            "cuelist_id": self.cuelist_id,
+            "ms_fadein": self.ms_fadein,
+            "ms_crossfade": self.ms_crossfade,
+            "no_first_fade": self.no_first_fade,
+            "name": self.name,
+            "block_fx": self.block_fx,
+            "cuelist_elements": {dotted_id: elem.to_dict() for dotted_id, elem in self.cuelist_elements.items()},
+            "ms_flash_hold": self.ms_flash_hold,
+            "ms_stop_time": self.ms_stop_time,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Cuelist":
+        if data is None:
+            return None
+        cuelist_elements = {int(dotted_id): CuelistElement.from_dict(elem) for dotted_id, elem in data.get("cuelist_elements", {}).items()}
+        return cls(
+            ms_flash_attack=data.get("ms_flash_attack"),
+            autoreset=data.get("autoreset"),
+            at_end_pause=data.get("at_end_pause"),
+            loops=data.get("loops"),
+            chase=data.get("chase"),
+            ms_chase_time=data.get("ms_chase_time"),
+            visual_id=data.get("visual_id"),
+            bpm_chase=data.get("bpm_chase"),
+            ms_flash_decay=data.get("ms_flash_decay"),
+            pcrossfade=data.get("pcrossfade"),
+            ms_fadeout=data.get("ms_fadeout"),
+            direction=data.get("direction"),
+            at_end_stop=data.get("at_end_stop"),
+            flash_mode=data.get("flash_mode"),
+            cuelist_id=data.get("cuelist_id"),
+            ms_fadein=data.get("ms_fadein"),
+            ms_crossfade=data.get("ms_crossfade"),
+            no_first_fade=data.get("no_first_fade"),
+            name=data.get("name"),
+            block_fx=data.get("block_fx"),
+            cuelist_elements=cuelist_elements,
+            ms_flash_hold=data.get("ms_flash_hold"),
+            ms_stop_time=data.get("ms_stop_time"),
+        )
+
+    def to_bytes(self) -> bytes:
+        logger.debug(f"Starting serialisation of Cuelist object {self.name}")
+        bytestr = bytearray(serialise_section_header("cuelist"))
+        content = bytearray()
+        num_attr = 0
+        
+        num_attrs = [
+            "ms_flash_attack", "ms_flash_decay", "ms_flash_hold", "ms_chase_time", "ms_fadein", "ms_fadeout",
+            "ms_crossfade", "ms_stop_time", "visual_id", "bpm_chase", "pcrossfade", "direction", "flash_mode", "cuelist_id", "loops"
+        ]
+        bool_attrs = ["autoreset", "chase", "at_end_pause", "at_end_stop", "no_first_fade", "block_fx"]
+        string_attrs = ["name"]
+        
+        for attr_name, attr_value in self.__dict__.items():
+            if attr_value is not None:
+                content.extend(serialise_attr_name(attr_name))
+                num_attr += 1
+
+                if attr_name in num_attrs:
+                    content.extend(serialise_num_value(attr_value, cc_check=True))
+                elif attr_name in bool_attrs:
+                    content.extend(serialise_bool_value(attr_value))
+                elif attr_name in string_attrs:
+                    content.extend(serialise_str_value(attr_value))
+                elif attr_name == "cuelist_elements":
+                    num_elements = len(attr_value) if attr_value else 0
+                    content.extend(serialise_objlist_len(num_elements))
+                    if attr_value:  # Only process if there are elements
+                        # Sort by dotted_id to maintain consistent order
+                        for dotted_id in sorted(attr_value.keys()):
+                            element = attr_value[dotted_id]
+                            content.extend(element.to_bytes())
+
+        content[0:0] = serialise_num_attr(num_attr)
+        bytestr.extend(serialise_content_length(content))
+        bytestr.extend(content)
+        logger.info("Cuelist object serialised")
+        logger.debug(bytestr)
+        return bytes(bytestr)
+
+
+class CuelistElement:
+    def __init__(
+        self,
+        ms_fadeout: Optional[int] = None,
+        cue_id: Optional[int] = None,
+        ms_delay: Optional[int] = None,
+        next: Optional[Union[int, str]] = "Next",
+        dotted_id: Optional[int] = None,
+        ms_fadein: Optional[int] = None,
+        ms_crossfade: Optional[int] = None,
+        ms_duration: Optional[int] = None,
+        halt: Optional[bool] = None,
+    ) -> None:
+        self.ms_fadeout: Optional[int] = ms_fadeout
+        self.cue_id: Optional[int] = cue_id
+        self.ms_delay: Optional[int] = ms_delay
+        self.next: Optional[Union[int, str]] = next
+        self.dotted_id: Optional[int] = dotted_id
+        self.ms_fadein: Optional[int] = ms_fadein
+        self.ms_crossfade: Optional[int] = ms_crossfade
+        self.ms_duration: Optional[int] = ms_duration
+        self.halt: Optional[bool] = halt
+
+
+    def __repr__(self):
+        return (
+            f"CuelistElement(ms_fadeout={self.ms_fadeout!r}, cue_id={self.cue_id!r}, "
+            f"ms_delay={self.ms_delay!r}, next={self.next!r}, dotted_id={self.dotted_id!r}, "
+            f"ms_fadein={self.ms_fadein!r}, ms_crossfade={self.ms_crossfade!r}, "
+            f"ms_duration={self.ms_duration!r}, halt={self.halt!r})"
+        )
+
+    def to_dict(self) -> dict:
+        return {
+            "ms_fadeout": self.ms_fadeout,
+            "cue_id": self.cue_id,
+            "ms_delay": self.ms_delay,
+            "next": self.next,
+            "dotted_id": self.dotted_id,
+            "ms_fadein": self.ms_fadein,
+            "ms_crossfade": self.ms_crossfade,
+            "ms_duration": self.ms_duration,
+            "halt": self.halt,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "CuelistElement":
+        # Handle migration from "N/A" to "Next"
+        next_value = data.get("next")
+        if next_value == "N/A":
+            next_value = "Next"
+        
+        return cls(
+            ms_fadeout=data.get("ms_fadeout"),
+            cue_id=data.get("cue_id"),
+            ms_delay=data.get("ms_delay"),
+            next=next_value,
+            dotted_id=data.get("dotted_id"),
+            ms_fadein=data.get("ms_fadein"),
+            ms_crossfade=data.get("ms_crossfade"),
+            ms_duration=data.get("ms_duration"),
+            halt=data.get("halt"),
+        )
+
+    def to_bytes(self) -> bytes:
+        logger.debug(f"Starting serialization of CuelistElement object {self.cue_id}")
+        bytestr = bytearray()
+        num_attr = 0
+        
+        num_attrs = [
+            "ms_fadeout", "cue_id", "ms_delay", "dotted_id", "ms_fadein", "ms_crossfade",
+            "ms_duration"
+        ]
+        bool_attrs = ["halt"]
+        
+        for attr_name, attr_value in self.__dict__.items():
+            if attr_value is not None:
+                bytestr.extend(serialise_attr_name(attr_name))
+                num_attr += 1
+                
+                if attr_name == "next":
+                    if attr_value == "Next" or attr_value == "N/A":
+                        bytestr.extend(b'\xFF')
+                    else:
+                        bytestr.extend(serialise_num_value(attr_value, cc_check=True))
+                elif attr_name in num_attrs:
+                    bytestr.extend(serialise_num_value(attr_value, cc_check=True))
+                elif attr_name in bool_attrs:
+                    bytestr.extend(serialise_bool_value(attr_value))
+
+        bytestr[0:0] = serialise_num_attr(num_attr)
+        logger.info("CuelistElement object serialised")
+        logger.debug(bytestr)
+        return bytes(bytestr)

lightshark_parser/classes/fileinfo.py

@@ -0,0 +1,98 @@
+from typing import Dict, List, Any, Optional
+from dataclasses import dataclass
+from lightshark_parser.serialisers.attribute_serialisers import *
+from lightshark_parser.utils.logger import logger
+
+
+
+@dataclass
+class Version:
+    subversion: int = None
+    version: int = None
+    autoload: bool = None
+    software: str = None
+
+
+    def __repr__(self):
+        return f"Version(subversion={self.subversion!r}, version={self.version!r}, autoload={self.autoload!r}, software={self.software!r})"
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "subversion": self.subversion,
+            "version": self.version,
+            "autoload": self.autoload,
+            "software": self.software,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Version":
+        return cls(
+            subversion=data.get("subversion"),
+            version=data.get("version"),
+            autoload=data.get("autoload"),
+            software=data.get("software"),
+        )
+
+    def to_bytes(self):
+        logger.debug(f"Starting serialization of Version object")
+        bytestr = bytearray(serialise_section_header("version"))
+
+        content = bytearray()
+        num_attr = 0
+        
+        num_attrs = ["subversion", "version"]
+        bool_attrs = ["autoload"]
+        string_attrs = ["software"]
+        
+        for attr_name, value in self.__dict__.items():
+            if value is not None:
+                content.extend(serialise_attr_name(attr_name))
+                num_attr += 1
+
+                if attr_name in num_attrs:
+                    content.extend(serialise_num_value(value))
+                elif attr_name in bool_attrs:
+                    content.extend(serialise_bool_value(value))
+                elif attr_name in string_attrs:
+                    content.extend(serialise_str_value(value))
+
+        content[0:0] = serialise_num_attr(num_attr)
+        
+        bytestr.extend(serialise_content_length(content))
+        bytestr.extend(content)
+        logger.info("FileInfo version object serialised")
+        logger.debug(bytestr)
+        return bytes(bytestr)
+        
+
+class FileInfo:
+
+
+    def __init__(self, version: Optional[Version] = None):
+        self.version = version if version is not None else self.Version()
+
+
+    def __repr__(self):
+        return f"FileInfo(version={self.version!r})"
+
+
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {"version": self.version.to_dict() if self.version else None}
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "FileInfo":
+        if data is None:
+            return None
+        version = Version.from_dict(data.get("version")) if data.get("version") else None
+        return cls(version=version)
+
+    def to_bytes(self):
+        logger.debug(f"Starting serialization of FileInfo section")
+        bytestr = bytearray(serialise_section_header("#fileinfo#"))
+        for obj in self.__dict__.values():
+            if obj is not None:
+                bytestr.extend(obj.to_bytes())
+        logger.info("FileInfo section serialised")
+        logger.debug(bytestr)
+        return bytes(bytestr)