14706437845

Committed 28 Apr 2025 11:16AM UTC coverage: 80.149% (+0.1%) from 80.035%

Build # 14706437845

Build Type

Pull #1764

github

Committed by

web-flow

Commit Message

Merge 1ce583a5e into 29ef085a0

Pull Request Pull Request #1764: Add tool calling support + Berekley Tool Calling Benchmark (simple-v3)

Run Details

1643 of 2034 branches covered (80.78%)

Branch coverage included in aggregate %.

10268 of 12827 relevant lines covered (80.05%)

0.8 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.11

src/unitxt/collections_operators.py

from typing import Any, Dict, Generator, List, Optional

from .dict_utils import dict_get, dict_set
from .operators import FieldOperator, StreamOperator
from .stream import Stream
from .utils import recursive_shallow_copy


class Dictify(FieldOperator):
    with_keys: List[str]

    def process_value(self, tup: Any) -> Any:
        return dict(zip(self.with_keys, tup))

class DictToTuplesList(FieldOperator):

    def process_value(self, dic: Dict) -> Any:
        return list(dic.items())

class Wrap(FieldOperator):
    inside: str

    def verify(self):
        super().verify()
        if self.inside not in ["list", "tuple", "set"]:
            raise ValueError(
                f"Wrap.inside support only types: [list, tuple, set], got {self.inside}"
            )

    def process_value(self, value: Any) -> Any:
        if self.inside == "list":
            return [value]
        if self.inside == "tuple":
            return (value,)
        return {
            value,
        }


class Chunk(FieldOperator):
    size: int

    def process_value(self, collection: Any) -> Any:
        return [
            collection[i : i + self.size] for i in range(0, len(collection), self.size)
        ]


class Slice(FieldOperator):
    start: Optional[int] = None
    stop: Optional[int] = None
    step: Optional[int] = None

    def process_value(self, collection: Any) -> Any:
        slicer = slice(self.start, self.stop, self.step)
        return collection[slicer]


class Get(FieldOperator):
    item: Any

    def process_value(self, collection: Any) -> Any:
        return collection[self.item]


class DuplicateByList(StreamOperator):
    field: str
    to_field: Optional[str] = None
    use_deep_copy: bool = False

    def process(self, stream: Stream, stream_name: Optional[str] = None) -> Generator:
        to_field = self.field if self.to_field is None else self.to_field
        for instance in stream:
            elements = dict_get(instance, self.field)
            for element in elements:
                if self.use_deep_copy:
                    instance_copy = recursive_shallow_copy(instance)

                else:
                    instance_copy = instance.copy()
                dict_set(instance_copy, to_field, element)
                yield instance_copy


class Explode(DuplicateByList):
    pass


class DuplicateBySubLists(StreamOperator):
    field: str
    to_field: Optional[str] = None
    use_deep_copy: bool = False

    def process(self, stream: Stream, stream_name: Optional[str] = None) -> Generator:
        to_field = self.field if self.to_field is None else self.to_field
        for instance in stream:
            elements = instance[self.field]
            for i in range(1, len(elements) + 1):
                if self.use_deep_copy:
                    instance_copy = recursive_shallow_copy(instance)
                    instance_copy[to_field] = elements[:i]
                else:
                    instance_copy = {
                        **instance,
                        self.field: elements,
                        to_field: elements[:i],
                    }
                yield instance_copy


class GetLength(FieldOperator):
    def process_value(self, collection: Any) -> Any:
        return len(collection)


class Filter(FieldOperator):
    values: List[Any]

    def process_value(self, collection: Any) -> Any:
        # If collection is a list, tuple, or set
        if isinstance(collection, (list, set, tuple)):
            return type(collection)(
                item for item in collection if item not in self.values
            )

        # If collection is a dictionary, filter by keys
        if isinstance(collection, dict):
            return {k: v for k, v in collection.items() if k not in self.values}

        # If collection is of an unsupported type
        raise TypeError(f"Unsupported collection type: {type(collection)}")

1	from typing import Any, Dict, Generator, List, Optional	1✔
2
3	from .dict_utils import dict_get, dict_set	1✔
4	from .operators import FieldOperator, StreamOperator	1✔
5	from .stream import Stream	1✔
6	from .utils import recursive_shallow_copy	1✔
7
8
9	class Dictify(FieldOperator):	1✔
10	with_keys: List[str]	1✔
11
12	def process_value(self, tup: Any) -> Any:	1✔
13	return dict(zip(self.with_keys, tup))	1✔
14
15	class DictToTuplesList(FieldOperator):	1✔
16
17	def process_value(self, dic: Dict) -> Any:	1✔
18	return list(dic.items())	×
19
20	class Wrap(FieldOperator):	1✔
21	inside: str	1✔
22
23	def verify(self):	1✔
24	super().verify()	1✔
25	if self.inside not in ["list", "tuple", "set"]:	1✔
26	raise ValueError(	1✔
27	f"Wrap.inside support only types: [list, tuple, set], got {self.inside}"
28	)
29
30	def process_value(self, value: Any) -> Any:	1✔
31	if self.inside == "list":	1✔
32	return [value]	1✔
33	if self.inside == "tuple":	1✔
34	return (value,)	1✔
35	return {	×
36	value,
37	}
38
39
40	class Chunk(FieldOperator):	1✔
41	size: int	1✔
42
43	def process_value(self, collection: Any) -> Any:	1✔
44	return [	1✔
45	collection[i : i + self.size] for i in range(0, len(collection), self.size)
46	]
47
48
49	class Slice(FieldOperator):	1✔
50	start: Optional[int] = None	1✔
51	stop: Optional[int] = None	1✔
52	step: Optional[int] = None	1✔
53
54	def process_value(self, collection: Any) -> Any:	1✔
55	slicer = slice(self.start, self.stop, self.step)	1✔
56	return collection[slicer]	1✔
57
58
59	class Get(FieldOperator):	1✔
60	item: Any	1✔
61
62	def process_value(self, collection: Any) -> Any:	1✔
63	return collection[self.item]	1✔
64
65
66	class DuplicateByList(StreamOperator):	1✔
67	field: str	1✔
68	to_field: Optional[str] = None	1✔
69	use_deep_copy: bool = False	1✔
70
71	def process(self, stream: Stream, stream_name: Optional[str] = None) -> Generator:	1✔
72	to_field = self.field if self.to_field is None else self.to_field	1✔
73	for instance in stream:	1✔
74	elements = dict_get(instance, self.field)	1✔
75	for element in elements:	1✔
76	if self.use_deep_copy:	1✔
77	instance_copy = recursive_shallow_copy(instance)	1✔
78
79	else:
80	instance_copy = instance.copy()	1✔
81	dict_set(instance_copy, to_field, element)	1✔
82	yield instance_copy	1✔
83
84
85	class Explode(DuplicateByList):	1✔
86	pass	1✔
87
88
89	class DuplicateBySubLists(StreamOperator):	1✔
90	field: str	1✔
91	to_field: Optional[str] = None	1✔
92	use_deep_copy: bool = False	1✔
93
94	def process(self, stream: Stream, stream_name: Optional[str] = None) -> Generator:	1✔
95	to_field = self.field if self.to_field is None else self.to_field	1✔
96	for instance in stream:	1✔
97	elements = instance[self.field]	1✔
98	for i in range(1, len(elements) + 1):	1✔
99	if self.use_deep_copy:	1✔
100	instance_copy = recursive_shallow_copy(instance)	1✔
101	instance_copy[to_field] = elements[:i]	1✔
102	else:
103	instance_copy = {	1✔
104	**instance,
105	self.field: elements,
106	to_field: elements[:i],
107	}
108	yield instance_copy	1✔
109
110
111	class GetLength(FieldOperator):	1✔
112	def process_value(self, collection: Any) -> Any:	1✔
113	return len(collection)	1✔
114
115
116	class Filter(FieldOperator):	1✔
117	values: List[Any]	1✔
118
119	def process_value(self, collection: Any) -> Any:	1✔
120	# If collection is a list, tuple, or set
121	if isinstance(collection, (list, set, tuple)):	×
122	return type(collection)(	×
123	item for item in collection if item not in self.values
124	)
125
126	# If collection is a dictionary, filter by keys
127	if isinstance(collection, dict):	×
128	return {k: v for k, v in collection.items() if k not in self.values}	×
129
130	# If collection is of an unsupported type
131	raise TypeError(f"Unsupported collection type: {type(collection)}")	×

IBM / unitxt / 14706437845

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous