llama-stack 0.3.5__py3-none-any.whl → 0.4.1__py3-none-any.whl

llama_stack/strong_typing/topological.py

@@ -1,89 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the terms described in the LICENSE file in
-# the root directory of this source tree.
-
-"""
-Type-safe data interchange for Python data classes.
-
-:see: https://github.com/hunyadi/strong_typing
-"""
-
-from typing import Callable, Dict, Iterable, List, Optional, Set, TypeVar
-
-from .inspection import TypeCollector
-
-T = TypeVar("T")
-
-
-def topological_sort(graph: Dict[T, Set[T]]) -> List[T]:
-    """
-    Performs a topological sort of a graph.
-
-    Nodes with no outgoing edges are first. Nodes with no incoming edges are last.
-    The topological ordering is not unique.
-
-    :param graph: A dictionary of mappings from nodes to adjacent nodes. Keys and set members must be hashable.
-    :returns: The list of nodes in topological order.
-    """
-
-    # empty list that will contain the sorted nodes (in reverse order)
-    ordered: List[T] = []
-
-    seen: Dict[T, bool] = {}
-
-    def _visit(n: T) -> None:
-        status = seen.get(n)
-        if status is not None:
-            if status:  # node has a permanent mark
-                return
-            else:  # node has a temporary mark
-                raise RuntimeError(f"cycle detected in graph for node {n}")
-
-        seen[n] = False  # apply temporary mark
-        for m in graph[n]:  # visit all adjacent nodes
-            if m != n:  # ignore self-referencing nodes
-                _visit(m)
-
-        seen[n] = True  # apply permanent mark
-        ordered.append(n)
-
-    for n in graph.keys():
-        _visit(n)
-
-    return ordered
-
-
-def type_topological_sort(
-    types: Iterable[type],
-    dependency_fn: Optional[Callable[[type], Iterable[type]]] = None,
-) -> List[type]:
-    """
-    Performs a topological sort of a list of types.
-
-    Types that don't depend on other types (i.e. fundamental types) are first. Types on which no other types depend
-    are last. The topological ordering is not unique.
-
-    :param types: A list of types (simple or composite).
-    :param dependency_fn: Returns a list of additional dependencies for a class (e.g. classes referenced by a foreign key).
-    :returns: The list of types in topological order.
-    """
-
-    if not all(isinstance(typ, type) for typ in types):
-        raise TypeError("expected a list of types")
-
-    collector = TypeCollector()
-    collector.traverse_all(types)
-    graph = collector.graph
-
-    if dependency_fn:
-        new_types: Set[type] = set()
-        for source_type, references in graph.items():
-            dependent_types = dependency_fn(source_type)
-            references.update(dependent_types)
-            new_types.update(dependent_types)
-        for new_type in new_types:
-            graph[new_type] = set()
-
-    return topological_sort(graph)

llama_stack/ui/node_modules/flatted/python/flatted.py

@@ -1,149 +0,0 @@
-# ISC License
-#
-# Copyright (c) 2018-2025, Andrea Giammarchi, @WebReflection
-#
-# Permission to use, copy, modify, and/or distribute this software for any
-# purpose with or without fee is hereby granted, provided that the above
-# copyright notice and this permission notice appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-# REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-# AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-# INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-# LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
-# OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-# PERFORMANCE OF THIS SOFTWARE.
-
-import json as _json
-
-class _Known:
-    def __init__(self):
-        self.key = []
-        self.value = []
-
-class _String:
-    def __init__(self, value):
-        self.value = value
-
-
-def _array_keys(value):
-    keys = []
-    i = 0
-    for _ in value:
-        keys.append(i)
-        i += 1
-    return keys
-
-def _object_keys(value):
-    keys = []
-    for key in value:
-        keys.append(key)
-    return keys
-
-def _is_array(value):
-    return isinstance(value, (list, tuple))
-
-def _is_object(value):
-    return isinstance(value, dict)
-
-def _is_string(value):
-    return isinstance(value, str)
-
-def _index(known, input, value):
-    input.append(value)
-    index = str(len(input) - 1)
-    known.key.append(value)
-    known.value.append(index)
-    return index
-
-def _loop(keys, input, known, output):
-    for key in keys:
-        value = output[key]
-        if isinstance(value, _String):
-            _ref(key, input[int(value.value)], input, known, output)
-
-    return output
-
-def _ref(key, value, input, known, output):
-    if _is_array(value) and value not in known:
-        known.append(value)
-        value = _loop(_array_keys(value), input, known, value)
-    elif _is_object(value) and value not in known:
-        known.append(value)
-        value = _loop(_object_keys(value), input, known, value)
-
-    output[key] = value
-
-def _relate(known, input, value):
-    if _is_string(value) or _is_array(value) or _is_object(value):
-        try:
-            return known.value[known.key.index(value)]
-        except:
-            return _index(known, input, value)
-
-    return value
-
-def _transform(known, input, value):
-    if _is_array(value):
-        output = []
-        for val in value:
-            output.append(_relate(known, input, val))
-        return output
-
-    if _is_object(value):
-        obj = {}
-        for key in value:
-            obj[key] = _relate(known, input, value[key])
-        return obj
-
-    return value
-
-def _wrap(value):
-    if _is_string(value):
-        return _String(value)
-
-    if _is_array(value):
-        i = 0
-        for val in value:
-            value[i] = _wrap(val)
-            i += 1
-
-    elif _is_object(value):
-        for key in value:
-            value[key] = _wrap(value[key])
-
-    return value
-
-def parse(value, *args, **kwargs):
-    json = _json.loads(value, *args, **kwargs)
-    wrapped = []
-    for value in json:
-        wrapped.append(_wrap(value))
-
-    input = []
-    for value in wrapped:
-        if isinstance(value, _String):
-            input.append(value.value)
-        else:
-            input.append(value)
-
-    value = input[0]
-
-    if _is_array(value):
-        return _loop(_array_keys(value), input, [value], value)
-
-    if _is_object(value):
-        return _loop(_object_keys(value), input, [value], value)
-
-    return value
-
-
-def stringify(value, *args, **kwargs):
-    known = _Known()
-    input = []
-    output = []
-    i = int(_index(known, input, value))
-    while i < len(input):
-        output.append(_transform(known, input, input[i]))
-        i += 1
-    return _json.dumps(output, *args, **kwargs)