npm - claude-all-hands - Versions diffs - 1.0.0 → 1.0.1 - Mend

claude-all-hands 1.0.0 → 1.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1424) hide show

package/.claude/envoy/.venv/lib/python3.9/site-packages/pyasn1/type/namedval.py DELETED Viewed

@@ -1,192 +0,0 @@
-#
-# This file is part of pyasn1 software.
-#
-# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
-# License: https://pyasn1.readthedocs.io/en/latest/license.html
-#
-# ASN.1 named integers
-#
-from pyasn1 import error
-__all__ = ['NamedValues']
-class NamedValues(object):
-    """Create named values object.
-    The |NamedValues| object represents a collection of string names
-    associated with numeric IDs. These objects are used for giving
-    names to otherwise numerical values.
-    |NamedValues| objects are immutable and duck-type Python
-    :class:`dict` object mapping ID to name and vice-versa.
-    Parameters
-    ----------
-    *args: variable number of two-element :py:class:`tuple`
-        name: :py:class:`str`
-            Value label
-        value: :py:class:`int`
-            Numeric value
-    Keyword Args
-    ------------
-    name: :py:class:`str`
-        Value label
-    value: :py:class:`int`
-        Numeric value
-    Examples
-    --------
-    .. code-block:: pycon
-        >>> nv = NamedValues('a', 'b', ('c', 0), d=1)
-        >>> nv
-        >>> {'c': 0, 'd': 1, 'a': 2, 'b': 3}
-        >>> nv[0]
-        'c'
-        >>> nv['a']
-        2
-    """
-    def __init__(self, *args, **kwargs):
-        self.__names = {}
-        self.__numbers = {}
-        anonymousNames = []
-        for namedValue in args:
-            if isinstance(namedValue, (tuple, list)):
-                try:
-                    name, number = namedValue
-                except ValueError:
-                    raise error.PyAsn1Error('Not a proper attribute-value pair %r' % (namedValue,))
-            else:
-                anonymousNames.append(namedValue)
-                continue
-            if name in self.__names:
-                raise error.PyAsn1Error('Duplicate name %s' % (name,))
-            if number in self.__numbers:
-                raise error.PyAsn1Error('Duplicate number  %s=%s' % (name, number))
-            self.__names[name] = number
-            self.__numbers[number] = name
-        for name, number in kwargs.items():
-            if name in self.__names:
-                raise error.PyAsn1Error('Duplicate name %s' % (name,))
-            if number in self.__numbers:
-                raise error.PyAsn1Error('Duplicate number  %s=%s' % (name, number))
-            self.__names[name] = number
-            self.__numbers[number] = name
-        if anonymousNames:
-            number = self.__numbers and max(self.__numbers) + 1 or 0
-            for name in anonymousNames:
-                if name in self.__names:
-                    raise error.PyAsn1Error('Duplicate name %s' % (name,))
-                self.__names[name] = number
-                self.__numbers[number] = name
-                number += 1
-    def __repr__(self):
-        representation = ', '.join(['%s=%d' % x for x in self.items()])
-        if len(representation) > 64:
-            representation = representation[:32] + '...' + representation[-32:]
-        return '<%s object, enums %s>' % (
-            self.__class__.__name__, representation)
-    def __eq__(self, other):
-        return dict(self) == other
-    def __ne__(self, other):
-        return dict(self) != other
-    def __lt__(self, other):
-        return dict(self) < other
-    def __le__(self, other):
-        return dict(self) <= other
-    def __gt__(self, other):
-        return dict(self) > other
-    def __ge__(self, other):
-        return dict(self) >= other
-    def __hash__(self):
-        return hash(self.items())
-    # Python dict protocol (read-only)
-    def __getitem__(self, key):
-        try:
-            return self.__numbers[key]
-        except KeyError:
-            return self.__names[key]
-    def __len__(self):
-        return len(self.__names)
-    def __contains__(self, key):
-        return key in self.__names or key in self.__numbers
-    def __iter__(self):
-        return iter(self.__names)
-    def values(self):
-        return iter(self.__numbers)
-    def keys(self):
-        return iter(self.__names)
-    def items(self):
-        for name in self.__names:
-            yield name, self.__names[name]
-    # support merging
-    def __add__(self, namedValues):
-        return self.__class__(*tuple(self.items()) + tuple(namedValues.items()))
-    # XXX clone/subtype?
-    def clone(self, *args, **kwargs):
-        new = self.__class__(*args, **kwargs)
-        return self + new
-    # legacy protocol
-    def getName(self, value):
-        if value in self.__numbers:
-            return self.__numbers[value]
-    def getValue(self, name):
-        if name in self.__names:
-            return self.__names[name]
-    def getValues(self, *names):
-        try:
-            return [self.__names[name] for name in names]
-        except KeyError:
-            raise error.PyAsn1Error(
-                'Unknown bit identifier(s): %s' % (set(names).difference(self.__names),)
-            )

package/.claude/envoy/.venv/lib/python3.9/site-packages/pyasn1/type/opentype.py DELETED Viewed

@@ -1,104 +0,0 @@
-#
-# This file is part of pyasn1 software.
-#
-# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
-# License: https://pyasn1.readthedocs.io/en/latest/license.html
-#
-__all__ = ['OpenType']
-class OpenType(object):
-    """Create ASN.1 type map indexed by a value
-    The *OpenType* object models an untyped field of a constructed ASN.1
-    type. In ASN.1 syntax it is usually represented by the
-    `ANY DEFINED BY` for scalars or `SET OF ANY DEFINED BY`,
-    `SEQUENCE OF ANY DEFINED BY` for container types clauses. Typically
-    used together with :class:`~pyasn1.type.univ.Any` object.
-    OpenType objects duck-type a read-only Python :class:`dict` objects,
-    however the passed `typeMap` is not copied, but stored by reference.
-    That means the user can manipulate `typeMap` at run time having this
-    reflected on *OpenType* object behavior.
-    The |OpenType| class models an untyped field of a constructed ASN.1
-    type. In ASN.1 syntax it is usually represented by the
-    `ANY DEFINED BY` for scalars or `SET OF ANY DEFINED BY`,
-    `SEQUENCE OF ANY DEFINED BY` for container types clauses. Typically
-    used with :class:`~pyasn1.type.univ.Any` type.
-    Parameters
-    ----------
-    name: :py:class:`str`
-        Field name
-    typeMap: :py:class:`dict`
-        A map of value->ASN.1 type. It's stored by reference and can be
-        mutated later to register new mappings.
-    Examples
-    --------
-    For untyped scalars:
-    .. code-block:: python
-        openType = OpenType(
-            'id', {1: Integer(),
-                   2: OctetString()}
-        )
-        Sequence(
-            componentType=NamedTypes(
-                NamedType('id', Integer()),
-                NamedType('blob', Any(), openType=openType)
-            )
-        )
-    For untyped `SET OF` or `SEQUENCE OF` vectors:
-    .. code-block:: python
-        openType = OpenType(
-            'id', {1: Integer(),
-                   2: OctetString()}
-        )
-        Sequence(
-            componentType=NamedTypes(
-                NamedType('id', Integer()),
-                NamedType('blob', SetOf(componentType=Any()),
-                          openType=openType)
-            )
-        )
-    """
-    def __init__(self, name, typeMap=None):
-        self.__name = name
-        if typeMap is None:
-            self.__typeMap = {}
-        else:
-            self.__typeMap = typeMap
-    @property
-    def name(self):
-        return self.__name
-    # Python dict protocol
-    def values(self):
-        return self.__typeMap.values()
-    def keys(self):
-        return self.__typeMap.keys()
-    def items(self):
-        return self.__typeMap.items()
-    def __contains__(self, key):
-        return key in self.__typeMap
-    def __getitem__(self, key):
-        return self.__typeMap[key]
-    def __iter__(self):
-        return iter(self.__typeMap)

package/.claude/envoy/.venv/lib/python3.9/site-packages/pyasn1/type/tag.py DELETED Viewed

@@ -1,335 +0,0 @@
-#
-# This file is part of pyasn1 software.
-#
-# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
-# License: https://pyasn1.readthedocs.io/en/latest/license.html
-#
-from pyasn1 import error
-__all__ = ['tagClassUniversal', 'tagClassApplication', 'tagClassContext',
-           'tagClassPrivate', 'tagFormatSimple', 'tagFormatConstructed',
-           'tagCategoryImplicit', 'tagCategoryExplicit',
-           'tagCategoryUntagged', 'Tag', 'TagSet']
-#: Identifier for ASN.1 class UNIVERSAL
-tagClassUniversal = 0x00
-#: Identifier for ASN.1 class APPLICATION
-tagClassApplication = 0x40
-#: Identifier for ASN.1 class context-specific
-tagClassContext = 0x80
-#: Identifier for ASN.1 class private
-tagClassPrivate = 0xC0
-#: Identifier for "simple" ASN.1 structure (e.g. scalar)
-tagFormatSimple = 0x00
-#: Identifier for "constructed" ASN.1 structure (e.g. may have inner components)
-tagFormatConstructed = 0x20
-tagCategoryImplicit = 0x01
-tagCategoryExplicit = 0x02
-tagCategoryUntagged = 0x04
-class Tag(object):
-    """Create ASN.1 tag
-    Represents ASN.1 tag that can be attached to a ASN.1 type to make
-    types distinguishable from each other.
-    *Tag* objects are immutable and duck-type Python :class:`tuple` objects
-    holding three integer components of a tag.
-    Parameters
-    ----------
-    tagClass: :py:class:`int`
-        Tag *class* value
-    tagFormat: :py:class:`int`
-        Tag *format* value
-    tagId: :py:class:`int`
-        Tag ID value
-    """
-    def __init__(self, tagClass, tagFormat, tagId):
-        if tagId < 0:
-            raise error.PyAsn1Error('Negative tag ID (%s) not allowed' % tagId)
-        self.__tagClass = tagClass
-        self.__tagFormat = tagFormat
-        self.__tagId = tagId
-        self.__tagClassId = tagClass, tagId
-        self.__hash = hash(self.__tagClassId)
-    def __repr__(self):
-        representation = '[%s:%s:%s]' % (
-            self.__tagClass, self.__tagFormat, self.__tagId)
-        return '<%s object, tag %s>' % (
-            self.__class__.__name__, representation)
-    def __eq__(self, other):
-        return self.__tagClassId == other
-    def __ne__(self, other):
-        return self.__tagClassId != other
-    def __lt__(self, other):
-        return self.__tagClassId < other
-    def __le__(self, other):
-        return self.__tagClassId <= other
-    def __gt__(self, other):
-        return self.__tagClassId > other
-    def __ge__(self, other):
-        return self.__tagClassId >= other
-    def __hash__(self):
-        return self.__hash
-    def __getitem__(self, idx):
-        if idx == 0:
-            return self.__tagClass
-        elif idx == 1:
-            return self.__tagFormat
-        elif idx == 2:
-            return self.__tagId
-        else:
-            raise IndexError
-    def __iter__(self):
-        yield self.__tagClass
-        yield self.__tagFormat
-        yield self.__tagId
-    def __and__(self, otherTag):
-        return self.__class__(self.__tagClass & otherTag.tagClass,
-                              self.__tagFormat & otherTag.tagFormat,
-                              self.__tagId & otherTag.tagId)
-    def __or__(self, otherTag):
-        return self.__class__(self.__tagClass | otherTag.tagClass,
-                              self.__tagFormat | otherTag.tagFormat,
-                              self.__tagId | otherTag.tagId)
-    @property
-    def tagClass(self):
-        """ASN.1 tag class
-        Returns
-        -------
-        : :py:class:`int`
-            Tag class
-        """
-        return self.__tagClass
-    @property
-    def tagFormat(self):
-        """ASN.1 tag format
-        Returns
-        -------
-        : :py:class:`int`
-            Tag format
-        """
-        return self.__tagFormat
-    @property
-    def tagId(self):
-        """ASN.1 tag ID
-        Returns
-        -------
-        : :py:class:`int`
-            Tag ID
-        """
-        return self.__tagId
-class TagSet(object):
-    """Create a collection of ASN.1 tags
-    Represents a combination of :class:`~pyasn1.type.tag.Tag` objects
-    that can be attached to a ASN.1 type to make types distinguishable
-    from each other.
-    *TagSet* objects are immutable and duck-type Python :class:`tuple` objects
-    holding arbitrary number of :class:`~pyasn1.type.tag.Tag` objects.
-    Parameters
-    ----------
-    baseTag: :class:`~pyasn1.type.tag.Tag`
-        Base *Tag* object. This tag survives IMPLICIT tagging.
-    *superTags: :class:`~pyasn1.type.tag.Tag`
-        Additional *Tag* objects taking part in subtyping.
-    Examples
-    --------
-    .. code-block:: python
-        class OrderNumber(NumericString):
-            '''
-            ASN.1 specification
-            Order-number ::=
-                [APPLICATION 5] IMPLICIT NumericString
-            '''
-            tagSet = NumericString.tagSet.tagImplicitly(
-                Tag(tagClassApplication, tagFormatSimple, 5)
-            )
-        orderNumber = OrderNumber('1234')
-    """
-    def __init__(self, baseTag=(), *superTags):
-        self.__baseTag = baseTag
-        self.__superTags = superTags
-        self.__superTagsClassId = tuple(
-            [(superTag.tagClass, superTag.tagId) for superTag in superTags]
-        )
-        self.__lenOfSuperTags = len(superTags)
-        self.__hash = hash(self.__superTagsClassId)
-    def __repr__(self):
-        representation = '-'.join(['%s:%s:%s' % (x.tagClass, x.tagFormat, x.tagId)
-                                   for x in self.__superTags])
-        if representation:
-            representation = 'tags ' + representation
-        else:
-            representation = 'untagged'
-        return '<%s object, %s>' % (self.__class__.__name__, representation)
-    def __add__(self, superTag):
-        return self.__class__(self.__baseTag, *self.__superTags + (superTag,))
-    def __radd__(self, superTag):
-        return self.__class__(self.__baseTag, *(superTag,) + self.__superTags)
-    def __getitem__(self, i):
-        if i.__class__ is slice:
-            return self.__class__(self.__baseTag, *self.__superTags[i])
-        else:
-            return self.__superTags[i]
-    def __eq__(self, other):
-        return self.__superTagsClassId == other
-    def __ne__(self, other):
-        return self.__superTagsClassId != other
-    def __lt__(self, other):
-        return self.__superTagsClassId < other
-    def __le__(self, other):
-        return self.__superTagsClassId <= other
-    def __gt__(self, other):
-        return self.__superTagsClassId > other
-    def __ge__(self, other):
-        return self.__superTagsClassId >= other
-    def __hash__(self):
-        return self.__hash
-    def __len__(self):
-        return self.__lenOfSuperTags
-    @property
-    def baseTag(self):
-        """Return base ASN.1 tag
-        Returns
-        -------
-        : :class:`~pyasn1.type.tag.Tag`
-            Base tag of this *TagSet*
-        """
-        return self.__baseTag
-    @property
-    def superTags(self):
-        """Return ASN.1 tags
-        Returns
-        -------
-        : :py:class:`tuple`
-            Tuple of :class:`~pyasn1.type.tag.Tag` objects that this *TagSet* contains
-        """
-        return self.__superTags
-    def tagExplicitly(self, superTag):
-        """Return explicitly tagged *TagSet*
-        Create a new *TagSet* representing callee *TagSet* explicitly tagged
-        with passed tag(s). With explicit tagging mode, new tags are appended
-        to existing tag(s).
-        Parameters
-        ----------
-        superTag: :class:`~pyasn1.type.tag.Tag`
-            *Tag* object to tag this *TagSet*
-        Returns
-        -------
-        : :class:`~pyasn1.type.tag.TagSet`
-            New *TagSet* object
-        """
-        if superTag.tagClass == tagClassUniversal:
-            raise error.PyAsn1Error("Can't tag with UNIVERSAL class tag")
-        if superTag.tagFormat != tagFormatConstructed:
-            superTag = Tag(superTag.tagClass, tagFormatConstructed, superTag.tagId)
-        return self + superTag
-    def tagImplicitly(self, superTag):
-        """Return implicitly tagged *TagSet*
-        Create a new *TagSet* representing callee *TagSet* implicitly tagged
-        with passed tag(s). With implicit tagging mode, new tag(s) replace the
-        last existing tag.
-        Parameters
-        ----------
-        superTag: :class:`~pyasn1.type.tag.Tag`
-            *Tag* object to tag this *TagSet*
-        Returns
-        -------
-        : :class:`~pyasn1.type.tag.TagSet`
-            New *TagSet* object
-        """
-        if self.__superTags:
-            superTag = Tag(superTag.tagClass, self.__superTags[-1].tagFormat, superTag.tagId)
-        return self[:-1] + superTag
-    def isSuperTagSetOf(self, tagSet):
-        """Test type relationship against given *TagSet*
-        The callee is considered to be a supertype of given *TagSet*
-        tag-wise if all tags in *TagSet* are present in the callee and
-        they are in the same order.
-        Parameters
-        ----------
-        tagSet: :class:`~pyasn1.type.tag.TagSet`
-            *TagSet* object to evaluate against the callee
-        Returns
-        -------
-        : :py:class:`bool`
-            :obj:`True` if callee is a supertype of *tagSet*
-        """
-        if len(tagSet) < self.__lenOfSuperTags:
-            return False
-        return self.__superTags == tagSet[:self.__lenOfSuperTags]
-    # Backward compatibility
-    def getBaseTag(self):
-        return self.__baseTag
-def initTagSet(tag):
-    return TagSet(tag, tag)