Datasets:

aleenatron
/

sample_test_aleena

ArXiv:

Dataset card Files Files and versions

xet

Community

sample_test_aleena / src /lerobot /utils /io_utils.py

aleenatron

Upload folder using huggingface_hub

f4a62da verified about 1 year ago

Raw History Blame Contribute Delete

4.53 kB

#!/usr/bin/env python

# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import json
import warnings
from pathlib import Path
from typing import TypeVar

import imageio

JsonLike = str | int | float | bool | None | list["JsonLike"] | dict[str, "JsonLike"] | tuple["JsonLike", ...]
T = TypeVar("T", bound=JsonLike)


def write_video(video_path, stacked_frames, fps):
    # Filter out DeprecationWarnings raised from pkg_resources
    with warnings.catch_warnings():
        warnings.filterwarnings(
            "ignore", "pkg_resources is deprecated as an API", category=DeprecationWarning
        )
        imageio.mimsave(video_path, stacked_frames, fps=fps)


def deserialize_json_into_object(fpath: Path, obj: T) -> T:
    """
    Loads the JSON data from `fpath` and recursively fills `obj` with the
    corresponding values (strictly matching structure and types).
    Tuples in `obj` are expected to be lists in the JSON data, which will be
    converted back into tuples.
    """
    with open(fpath, encoding="utf-8") as f:
        data = json.load(f)

    def _deserialize(target, source):
        """
        Recursively overwrite the structure in `target` with data from `source`,
        performing strict checks on structure and type.
        Returns the updated version of `target` (especially important for tuples).
        """

        # If the target is a dictionary, source must be a dictionary as well.
        if isinstance(target, dict):
            if not isinstance(source, dict):
                raise TypeError(f"Type mismatch: expected dict, got {type(source)}")

            # Check that they have exactly the same set of keys.
            if target.keys() != source.keys():
                raise ValueError(
                    f"Dictionary keys do not match.\nExpected: {target.keys()}, got: {source.keys()}"
                )

            # Recursively update each key.
            for k in target:
                target[k] = _deserialize(target[k], source[k])

            return target

        # If the target is a list, source must be a list as well.
        elif isinstance(target, list):
            if not isinstance(source, list):
                raise TypeError(f"Type mismatch: expected list, got {type(source)}")

            # Check length
            if len(target) != len(source):
                raise ValueError(f"List length mismatch: expected {len(target)}, got {len(source)}")

            # Recursively update each element.
            for i in range(len(target)):
                target[i] = _deserialize(target[i], source[i])

            return target

        # If the target is a tuple, the source must be a list in JSON,
        # which we'll convert back to a tuple.
        elif isinstance(target, tuple):
            if not isinstance(source, list):
                raise TypeError(f"Type mismatch: expected list (for tuple), got {type(source)}")

            if len(target) != len(source):
                raise ValueError(f"Tuple length mismatch: expected {len(target)}, got {len(source)}")

            # Convert each element, forming a new tuple.
            converted_items = []
            for t_item, s_item in zip(target, source, strict=False):
                converted_items.append(_deserialize(t_item, s_item))

            # Return a brand new tuple (tuples are immutable in Python).
            return tuple(converted_items)

        # Otherwise, we're dealing with a "primitive" (int, float, str, bool, None).
        else:
            # Check the exact type.  If these must match 1:1, do:
            if type(target) is not type(source):
                raise TypeError(f"Type mismatch: expected {type(target)}, got {type(source)}")
            return source

    # Perform the in-place/recursive deserialization
    updated_obj = _deserialize(obj, data)
    return updated_obj

	#!/usr/bin/env python

	# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
	#
	# Licensed under the Apache License, Version 2.0 (the "License");
	# you may not use this file except in compliance with the License.
	# You may obtain a copy of the License at
	#
	# http://www.apache.org/licenses/LICENSE-2.0
	#
	# Unless required by applicable law or agreed to in writing, software
	# distributed under the License is distributed on an "AS IS" BASIS,
	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	# See the License for the specific language governing permissions and
	# limitations under the License.
	import json
	import warnings
	from pathlib import Path
	from typing import TypeVar

	import imageio

	JsonLike = str \| int \| float \| bool \| None \| list["JsonLike"] \| dict[str, "JsonLike"] \| tuple["JsonLike", ...]
	T = TypeVar("T", bound=JsonLike)


	def write_video(video_path, stacked_frames, fps):
	# Filter out DeprecationWarnings raised from pkg_resources
	with warnings.catch_warnings():
	warnings.filterwarnings(
	"ignore", "pkg_resources is deprecated as an API", category=DeprecationWarning
	)
	imageio.mimsave(video_path, stacked_frames, fps=fps)


	def deserialize_json_into_object(fpath: Path, obj: T) -> T:
	"""
	Loads the JSON data from `fpath` and recursively fills `obj` with the
	corresponding values (strictly matching structure and types).
	Tuples in `obj` are expected to be lists in the JSON data, which will be
	converted back into tuples.
	"""
	with open(fpath, encoding="utf-8") as f:
	data = json.load(f)

	def _deserialize(target, source):
	"""
	Recursively overwrite the structure in `target` with data from `source`,
	performing strict checks on structure and type.
	Returns the updated version of `target` (especially important for tuples).
	"""

	# If the target is a dictionary, source must be a dictionary as well.
	if isinstance(target, dict):
	if not isinstance(source, dict):
	raise TypeError(f"Type mismatch: expected dict, got {type(source)}")

	# Check that they have exactly the same set of keys.
	if target.keys() != source.keys():
	raise ValueError(
	f"Dictionary keys do not match.\nExpected: {target.keys()}, got: {source.keys()}"
	)

	# Recursively update each key.
	for k in target:
	target[k] = _deserialize(target[k], source[k])

	return target

	# If the target is a list, source must be a list as well.
	elif isinstance(target, list):
	if not isinstance(source, list):
	raise TypeError(f"Type mismatch: expected list, got {type(source)}")

	# Check length
	if len(target) != len(source):
	raise ValueError(f"List length mismatch: expected {len(target)}, got {len(source)}")

	# Recursively update each element.
	for i in range(len(target)):
	target[i] = _deserialize(target[i], source[i])

	return target

	# If the target is a tuple, the source must be a list in JSON,
	# which we'll convert back to a tuple.
	elif isinstance(target, tuple):
	if not isinstance(source, list):
	raise TypeError(f"Type mismatch: expected list (for tuple), got {type(source)}")

	if len(target) != len(source):
	raise ValueError(f"Tuple length mismatch: expected {len(target)}, got {len(source)}")

	# Convert each element, forming a new tuple.
	converted_items = []
	for t_item, s_item in zip(target, source, strict=False):
	converted_items.append(_deserialize(t_item, s_item))

	# Return a brand new tuple (tuples are immutable in Python).
	return tuple(converted_items)

	# Otherwise, we're dealing with a "primitive" (int, float, str, bool, None).
	else:
	# Check the exact type. If these must match 1:1, do:
	if type(target) is not type(source):
	raise TypeError(f"Type mismatch: expected {type(target)}, got {type(source)}")
	return source

	# Perform the in-place/recursive deserialization
	updated_obj = _deserialize(obj, data)
	return updated_obj