timmy-config/wizards/allegro-primus/capabilities/__pycache__/discovery.cpython-312.pyc

<EFBFBD>
d<0C>i<EFBFBD>.<00>

<01><><00>UdZd
dl
mZ
d
dlZd
dlZd
dlmZmZmZ
d
dl	m
Z
mZmZm
Z
mZmZ
d
dlmZ
d
dlmZ
d
dlZGd<08>d	e<12>ZGd
<EFBFBD>de<12>ZeGd<0C>d
<0A><00>ZeGd<0E>d<0F><00>ZGd<10>d<11>Zdaded<d2d3d<14>Zd<15>Zej:ddf							d4d<18>Zedk(<00>
r$ed<1A>
Z edejBdddddd <20>i
d!d"g<02>#<23>Z"ed$ej:d%d&dg
d'd(g<02>)<29>Z#e jIe"<22>

e jIe#<23>

e%d*e jM<00><00>
e%d+<2B>

e jO<00>D]1Z(e%d,e(jR<00>d-e(jT<00>d.e(jV<00><00><06>

<00>3ed'g
<01>/<2F>
Z,e jYe,<2C>
Z-e%d0e-D<00>cgc]}|jR<00><02>c}<00><00><02>

e%d1<64>

e%e j]<00><00>

yyc
c}w)5z]
AP Capability Registry

Manages registration, discovery, and versioning of AP capabilities.
<EFBFBD>)
<01>annotationsN)<03>	dataclass<73>field<6C>asdict)<06>Dict<63>List<73>Optional<61>Set<65>Any<6E>Callable)
<01>datetime)
<01>Enumc

<01>(<00>eZ
dZd
ZdZdZdZdZdZdZ	y)	<09>CapabilityTypez(Types of capabilities an agent can have.<2E>tool<6F>skill<6C>	knowledge<67>api<70>protocol<6F>serviceN)
<EFBFBD>__name__<5F>
__module__<EFBFBD>__qualname__<5F>__doc__<5F>TOOL<4F>SKILL<4C>	KNOWLEDGE<47>API<50>PROTOCOL<4F>SERVICE<43><00><00>6/root/wizards/allegro-primus/capabilities/discovery.pyrrs#<00><00>2<><11>D<EFBFBD><13>E<EFBFBD><1B>I<EFBFBD>
<0F>C<EFBFBD><19>H<EFBFBD><17>Gr"rc

<01> <00>eZ
dZd
ZdZdZdZdZy)<07>CapabilityStatuszStatus of a capability.<2E>active<76>
deprecated<EFBFBD>experimental<61>disabledN)rrrr<00>ACTIVE<56>
DEPRECATED<EFBFBD>EXPERIMENTAL<41>DISABLEDr!r"r#r%r%s<00><00>!<21>
<15>F<EFBFBD><1D>J<EFBFBD>!<21>L<EFBFBD><19>Hr"r%c
<01>d
<00>eZ
dZUd
Zded<ded<ded<ded<dZd	ed
<ee<07><0B>
Zded
<ee<07><0B>
Z	ded<ee
<EFBFBD><0B>
Zded<ee
<EFBFBD><0B>
Zded<e
jZded<ee<07><0B>
Zded<ed<15><00><0B>
Zded<ed<17><00><0B>
Zded<d<19>Zedd<1A><04>Zdd<1B>Zedd<1C><04>Zy) <20>
CapabilityzRepresents a single capability.<2E>str<74>namer<00>type<70>version<6F>descriptionN<6E>
Optional[str]<5D>endpoint)
<01>default_factory<72>Dict[str, Any]<5D>
parameters<EFBFBD>returnsz	List[str]<5D>dependencies<65>tagsr%<00>status<75>metadatac
<01>F<00>t
j<00>j<00>S<00>
N<>r
<00>utcnow<6F>	isoformatr!r"r#<00><lambda>zCapability.<lambda>3<00><00><00>H<EFBFBD>O<EFBFBD>O<EFBFBD>4E<34>4O<34>4O<34>4Q<34>r"<00>
created_atc
<01>F<00>t
j<00>j<00>Sr@rAr!r"r#rDzCapability.<lambda>4rEr"<00>
updated_atc

<01><><00>t
|jt<00>rt|j<00>
|_
t
|jt<00>rt|j<00>
|_yyr@)<06>
isinstancer2r0rr=r%<00>
<01>selfs
 r#<00>
__post_init__zCapability.__post_init__6sC<00><00><15>d<EFBFBD>i<EFBFBD>i<EFBFBD><13>%<25>&<26>t<EFBFBD>y<EFBFBD>y<EFBFBD>1<>D<EFBFBD>I<EFBFBD><15>d<EFBFBD>k<EFBFBD>k<EFBFBD>3<EFBFBD>'<27>*<2A>4<EFBFBD>;<3B>;<3B>7<>D<EFBFBD>K<EFBFBD>(r"c

<01><><00>|j<00>d
|j<00>d
|jj<00><00>}
t	j
|
j
<00><00>
j<00>ddS)z'Generate unique ID for this capability.<2E>
:N<>)r1r3r2<00>value<75>hashlib<69>sha256<35>encode<64>	hexdigest)rL<00>contents  r#<00>idz
Capability.id<sQ<00><00><1A>Y<EFBFBD>Y<EFBFBD>K<EFBFBD>q<EFBFBD><14><1C><1C><0E>a<EFBFBD><04>	<09>	<09><0F><0F>/@<40>A<><07><16>~<7E>~<7E>g<EFBFBD>n<EFBFBD>n<EFBFBD>.<2E>/<2F>9<>9<>;<3B>C<EFBFBD>R<EFBFBD>@<40>@r"c

<01><><00>t
|<00>
}
|j|
d
<|jj|
d<|jj|
d<|
S)zConvert to dictionary.rWr2r=)rrWr2rQr=)rL<00>datas  r#<00>to_dictzCapability.to_dictBsA<00><00><15>d<EFBFBD>|<7C><04><19>W<EFBFBD>W<EFBFBD><04>T<EFBFBD>
<EFBFBD><1B>y<EFBFBD>y<EFBFBD><EFBFBD><EFBFBD><04>V<EFBFBD><0C><1D><1B><1B>*<2A>*<2A><04>X<EFBFBD><0E><13>r"c
<01>V<00>|
j
<00>}
|
jd
d<02>
|di|
<01>
<01>
S)zCreate from dictionary.rWNr!)<02>copy<70>pop)<02>clsrYs  r#<00>	from_dictzCapability.from_dictJs)<00><00><14>y<EFBFBD>y<EFBFBD>{<7B><04><0C><08><08><14>t<EFBFBD><1C><12>{<7B>T<EFBFBD>{<7B>r")<02>returnr0<00>r`r8)rYr8r`r/)rrrr<00>__annotations__r6r<00>dictr9r:<00>listr;r<r%r*r=r>rFrHrM<00>propertyrWrZ<00>classmethodr_r!r"r#r/r/%s<><00><00>)<29>

<0A>I<EFBFBD>
<18><18>
<10>L<EFBFBD><14><14>"<22>H<EFBFBD>m<EFBFBD>"<22>!&<26>t<EFBFBD>!<<3C>J<EFBFBD><0E><<3C>#<23>D<EFBFBD>9<>G<EFBFBD>^<5E>9<>#<23>D<EFBFBD>9<>L<EFBFBD>)<29>9<><1B>D<EFBFBD>1<>D<EFBFBD>)<29>1<>/<2F>6<>6<>F<EFBFBD><1C>6<>$<24>T<EFBFBD>:<3A>H<EFBFBD>n<EFBFBD>:<3A><1B>,Q<>R<>J<EFBFBD><03>R<><1B>,Q<>R<>J<EFBFBD><03>R<>8<><0E>A
<01><0E>A
<01>
<14><11><1B><11>r"r/c
<01>f<00>eZ
dZUd
ZdZded<dZded<dZded<dZd	ed
<dZ	ded<dZ
ded<y)
<0A>CapabilityQueryz!Query for searching capabilities.Nr5<00>name_patternzOptional[List[CapabilityType]]<5D>typeszOptional[List[str]]r<zOptional[CapabilityStatus]r=<00>min_version<6F>
required_deps)rrrrrirbrjr<r=rkrlr!r"r#rhrhRsE<00><00>+<2B>"&<26>L<EFBFBD>-<2D>&<26>,0<>E<EFBFBD>)<29>0<> $<24>D<EFBFBD>
<1D>$<24>)-<2D>F<EFBFBD>&<26>-<2D>!%<25>K<EFBFBD><1D>%<25>)-<2D>M<EFBFBD>&<26>-r"rhc
<01><><00>eZ
dZd
Zdd<02>Zddd<04>Zdd<05>Zdd<06>Zddd<07>Zdd<08>Z	dd	<09>Z
dd
<EFBFBD>Zdd<0B>Zdd<0C>Z
dd
<0A>Zdd<0E>Zdd<0F>Zdd d<10>Zd!d<11>Zy)"<22>CapabilityRegistryz)Registry for managing agent capabilities.c
<01>n<00>|
|_i|_
i|_tj<00>|_d
|_y)Nr)<07>agent_id<69>
_capabilities<65>	_handlers<72>	threading<6E>RLock<63>_lock<63>_version_counter)rLrps  r#<00>__init__zCapabilityRegistry.__init__`s.<00><00> <20><04>
<0A>46<34><04><1A>.0<EFBFBD><04><0E><1E>_<EFBFBD>_<EFBFBD>&<26><04>
<EFBFBD> !<21><04>r"Nc
<01>6
<00>|j5
|
j}||jvr'tj<00>j<00>|
_|
|j|<|r||j|<|x
jd
z
c_|cddd<02>
S#1s
w
Y

yxYw
)z<>
        Register a new capability.
        
        Args:
            capability: The capability to register
            handler: Optional handler function for this capability
            
        Returns:
            Capability ID
        <20>
N)	rurWrqr
rBrCrHrrrv)rL<00>
capability<EFBFBD>handler<65>cap_ids    r#<00>registerzCapabilityRegistry.registergs<><00><00><12>Z<EFBFBD>Z<EFBFBD>	<1A><1F>]<5D>]<5D>F<EFBFBD><16><14>+<2B>+<2B>+<2B>(0<><0F><0F>(9<>(C<>(C<>(E<>
<EFBFBD>%<25>)3<>D<EFBFBD><1E><1E>v<EFBFBD>&<26><16>)0<><04><0E><0E>v<EFBFBD>&<26><10>!<21>!<21>Q<EFBFBD>&<26>!<21><19>	<1A>	<1A>	<1A>s<00>A8B<03>Bc
<01><><00>|j5
|
|jvrH|j|
=|jj|
d
<01>
|x
jdz
c_	d
d
d
<01>
y	d
d
d
<01>
y#1s
w
Y

y
xYw
)zUnregister a capability.NryTF)rurqrrr]rv<00>rLr|s  r#<00>
unregisterzCapabilityRegistry.unregister<65>sq<00><00>
<11>Z<EFBFBD>Z<EFBFBD>	<19><15><14>+<2B>+<2B>+<2B><18>&<26>&<26>v<EFBFBD>.<2E><14><0E><0E>"<22>"<22>6<EFBFBD>4<EFBFBD>0<><14>%<25>%<25><11>*<2A>%<25><1B>	<19>	<19><19>
	<19>	<19>	<19>s<00>AA.<03>$
A.<03>.A7c
<01>|<00>|j5
|jj|
<01>
cd
d
d
<01>
S#1s
w
Y

y
xYw
)zGet a capability by ID.N)rurq<00>getrs  r#r<>zCapabilityRegistry.get<65>s2<00><00>
<11>Z<EFBFBD>Z<EFBFBD>
	2<><17>%<25>%<25>)<29>)<29>&<26>1<>
	2<>
	2<>
	2<><32><00>2<03>;c
<01><><00>|j5
|jj<00>D]0}|j|
k(s
<01>|<02>|j|k(s
<01>%|c
cd
d
d
<01>
S	d
d
d
<01>
y
#1s
w
Y

y
xYw
)z.Get a capability by name and optional version.N)rurq<00>valuesr1r3)rLr1r3<00>caps    r#<00>get_by_namezCapabilityRegistry.get_by_name<6D>sl<00><00>
<11>Z<EFBFBD>Z<EFBFBD>	<18><1B>)<29>)<29>0<>0<>2<>
#<23><03><16>8<EFBFBD>8<EFBFBD>t<EFBFBD>#<23><1E><EFBFBD>#<23>+<2B>+<2B><17>*@<40>"<22>
<EFBFBD>		<18>	<18>
#<23><18>	<18>	<18>	<18>s<00>-A%<03>A%<03>
A%<03>A%<03>%A.c

<01><><00>|j5
t|jj<00><00>
cd
d
d
<01>
S#1s
w
Y

y
xYw
)z!List all registered capabilities.N)rurdrqr<>rKs
 r#<00>list_allzCapabilityRegistry.list_all<6C>s5<00><00>
<11>Z<EFBFBD>Z<EFBFBD>
	5<><17><04>*<2A>*<2A>1<>1<>3<>4<>
	5<>
	5<>
	5<>s	<00>#:<03>Ac
<01><<00><03>|j5
g}|jj<00>D]<5D><00>|
jr|
j<00>jv
r
<01>(|
j
r<19>j|
j
v
r
<01>M|
jrt<00>f
d
<01>|
jD<00><00>
s
<01>x|
jr<1A>j|
jk7r
<01><>|
jrt<00>f
d<02>|
jD<00><00>
s
<01><>|j<00><03>

<00><>|cddd<03>
S#1s
w
Y

yxYw
)z<>
        Query capabilities with filters.
        
        Args:
            query: Query parameters
            
        Returns:
            List of matching capabilities
        c
3
<01>:<00>
K
<00>|]}
|
<01>jv<00>
<01>

<00>y<00>w
r@<00>
r<)<03>.0<EFBFBD>tagr<67>s  <20>r#<00>	<genexpr>z+CapabilityRegistry.query.<locals>.<genexpr><3E>s<00><><00><><00>)P<>c<EFBFBD>#<23><13><18><18>/<2F>)P<><50><00>
c
3
<01>:<00>
K
<00>|]}
|
<01>jv<00>
<01>

<00>y<00>w
r@)
r;)r<><00>depr<70>s  <20>r#r<>z+CapabilityRegistry.query.<locals>.<genexpr><3E>s<00><><00><><00>V<>3<EFBFBD>s<EFBFBD>c<EFBFBD>&6<>&6<>6<>V<>r<EFBFBD>N)
rurqr<>rir1rjr2r<<00>anyr=rl<00>all<6C>append)rL<00>query<72>resultsr<73>s   @r#r<>zCapabilityRegistry.query<72>s<><00><><00><12>Z<EFBFBD>Z<EFBFBD>	<1B><18>G<EFBFBD><1B>)<29>)<29>0<>0<>2<>
$<24><03><18>%<25>%<25>%<25>*<<3C>*<<3C>C<EFBFBD>H<EFBFBD>H<EFBFBD>*L<><1C><19>;<3B>;<3B>3<EFBFBD>8<EFBFBD>8<EFBFBD>5<EFBFBD>;<3B>;<3B>#><3E><1C><19>:<3A>:<3A>c<EFBFBD>)P<>U<EFBFBD>Z<EFBFBD>Z<EFBFBD>)P<>&P<><1C><19><<3C><<3C>C<EFBFBD>J<EFBFBD>J<EFBFBD>%<25>,<2C>,<2C>$><3E><1C><19>&<26>&<26><1E>V<>%<25>BU<42>BU<42>V<>V<> <20><17><0E><0E>s<EFBFBD>#<23>-
$<24>0<1B>7	<1B>	<1B>	<1B>s<00>C:D<03>Dc
<01>|<00>|j5
|jj|
<01>
cd
d
d
<01>
S#1s
w
Y

y
xYw
)z!Get the handler for a capability.N)rurrr<>rs  r#<00>get_handlerzCapabilityRegistry.get_handler<65>s0<00><00>
<11>Z<EFBFBD>Z<EFBFBD>
	.<2E><17>><3E>><3E>%<25>%<25>f<EFBFBD>-<2D>
	.<2E>
	.<2E>
	.<2E>r<EFBFBD>c
<01>T<00>|j
|
<01>
}|<03>td
|
<01><00><02>
<00>
|di|<02>
<01>
S)z<>
        Execute a capability handler.
        
        Args:
            cap_id: Capability ID
            **kwargs: Arguments for the handler
            
        Returns:
            Handler result
        z%No handler registered for capability r!)r<><00>
ValueError)rLr|<00>kwargsr{s    r#<00>executezCapabilityRegistry.execute<74>s:<00><00><17>"<22>"<22>6<EFBFBD>*<2A><07><12>?<3F><1C>D<>V<EFBFBD>H<EFBFBD>M<>N<>N<><16> <20><16> <20> r"c
<01>

<00>|j5
|jj|
<01>
}|sgcd
d
d
<01>
Sg}|jD]'}|j	|<04>
}|s
<01>|j|<05>

<00>)|cd
d
d
<01>
S#1s
w
Y

y
xYw
)z&Get all dependencies for a capability.N)rurqr<>r;r<>r<>)rLr|r<><00>deps<70>dep_name<6D>dep_caps      r#<00>get_dependenciesz#CapabilityRegistry.get_dependencies<65>s<><00><00>
<11>Z<EFBFBD>Z<EFBFBD>	<18><16>$<24>$<24>(<28>(<28><16>0<>C<EFBFBD><16><19>	<18>	<18>
<16>D<EFBFBD><1F>,<2C>,<2C>
)<29><08><1E>*<2A>*<2A>8<EFBFBD>4<><07><1A><18>K<EFBFBD>K<EFBFBD><07>(<28>
)<29>
<18>	<18>	<18>	<18>s<00>A9<03>$A9<03>A9<03>9Bc
<01><><00>|j5
|jj|
<01>
}|sicd
d
d
<01>
S|jD<00>cic]}||j	|<03>
d
u
<01><02>c}cd
d
d
<01>
Sc
c}w#1s
w
Y

y
xYw
)z<>
        Check if all dependencies are satisfied.
        
        Returns:
            Dict mapping dependency names to satisfaction status
        N)rurqr<>r;r<>)rLr|r<>r<>s    r#<00>check_dependenciesz%CapabilityRegistry.check_dependencies<65>s<><00><00><12>Z<EFBFBD>Z<EFBFBD>	<0E><16>$<24>$<24>(<28>(<28><16>0<>C<EFBFBD><16><19>	<0E>	<0E><1F>+<2B>+<2B><0E><17><14>T<EFBFBD>%<25>%<25>c<EFBFBD>*<2A>$<24>6<>6<><0E>	<0E>	<0E><>
<0E>	<0E>	<0E>s"<00>A0<03>A0<03>A+<06>A0<03>+A0<03>0A9c

<01><>
<00>|j5
i}
i}|jj<00>D]<5D>}|
j|jj
d
<01>dz|
|jj
<|j|jj
d
<01>dz||jj
<<00><>t|j<00>
|j|
|t|j<00>
d<03>cddd<04>
S#1s
w
Y

yxYw
)zGet registry statistics.rry)<05>total_capabilitiesr3<00>by_type<70>	by_status<75>
with_handlersN)
rurqr<>r<>r2rQr=<00>lenrvrr)rL<00>type_counts<74>
status_countsr<73>s    r#<00>	get_statszCapabilityRegistry.get_stats<74>s<><00><00>
<11>Z<EFBFBD>Z<EFBFBD>	<0E><1C>K<EFBFBD><1E>M<EFBFBD><1B>)<29>)<29>0<>0<>2<>
]
<01><03>.9<EFBFBD>o<EFBFBD>o<EFBFBD>c<EFBFBD>h<EFBFBD>h<EFBFBD>n<EFBFBD>n<EFBFBD>a<EFBFBD>.P<>ST<53>.T<><0B>C<EFBFBD>H<EFBFBD>H<EFBFBD>N<EFBFBD>N<EFBFBD>+<2B>2?<3F>2C<32>2C<32>C<EFBFBD>J<EFBFBD>J<EFBFBD>DT<44>DT<44>VW<56>2X<32>[\<5C>2\<5C>
<0A>c<EFBFBD>j<EFBFBD>j<EFBFBD>.<2E>.<2E>/<2F>
]
<01>
'*<2A>$<24>*<<3C>*<<3C>&=<3D><1F>0<>0<>&<26>*<2A>!$<24>T<EFBFBD>^<5E>^<5E>!4<><0E>	<0E>	<0E>	<0E>s<00>CC2<03>2C;c
	
<01>.
<00>|j5
|j|jtj<00>j<00>|jj<00>D<00>
cgc]}
|
j<00><00><02>c}
d
<01>cddd<02>
Sc
c}
w#1s
w
Y

yxYw
)z&Export all capabilities as dictionary.)rpr3<00>exported_at<61>capabilitiesN)	rurprvr
rBrCrqr<>rZ)rLr<>s  r#<00>exportzCapabilityRegistry.export
st<00><00>
<11>Z<EFBFBD>Z<EFBFBD>	<0E> <20>M<EFBFBD>M<EFBFBD><1F>0<>0<>'<27><EFBFBD><EFBFBD>0<>:<3A>:<3A><<3C>:><3E>:L<>:L<>:S<>:S<>:U<> V<>3<EFBFBD><13><1B><1B><1D> V<>	<0E>	<0E>	<0E><>
!W
<01>	<0E>	<0E>s<00>AB<03>!B<0C>8B<03>B<03>Bc
<01>L<00>t
j|j<00>|
<01>
<01>S)z'Export all capabilities as JSON string.)
<01>indent)<03>json<6F>dumpsr<73>)rLr<>s  r#<00>export_jsonzCapabilityRegistry.export_json
s<00><00><13>z<EFBFBD>z<EFBFBD>$<24>+<2B>+<2B>-<2D><06>7<>7r"c
<01><><00>|j5
d
}|
jdg<00>D]-}tj|<03>
}|j	|<04>

|dz
}<02>/|cddd<04>
S#1s
w
Y

yxYw
)z$Import capabilities from dictionary.rr<>ryN)rur<>r/r_r})rLrY<00>count<6E>cap_datar<61>s     r#<00>import_capabilitiesz&CapabilityRegistry.import_capabilities
sg<00><00>
<11>Z<EFBFBD>Z<EFBFBD>	<19><15>E<EFBFBD> <20>H<EFBFBD>H<EFBFBD>^<5E>R<EFBFBD>8<>
<1B><08> <20>*<2A>*<2A>8<EFBFBD>4<><03><14>
<0A>
<0A>c<EFBFBD>"<22><15><11>
<EFBFBD><05>
<1B><19>
	<19>	<19>	<19>s<00>AA<03>A&)rpr0r@)rzr/r{<00>Optional[Callable]r`r0)r|r0r`<00>bool)r|r0r`<00>Optional[Capability])r1r0r3r5r`r<>)r`<00>List[Capability])r<>rhr`r<>)r|r0r`r<>)r|r0r`r)r|r0r`r<>)r|r0r`zDict[str, bool]ra)
<01>)r<><00>intr`r0)rYr8r`r<>)rrrrrwr}r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r!r"r#rnrn]sQ<00><00>3<>"<22><1A>6<19>2<>
<18>5<>
%<1B>N
.<2E>
!<21>"
<18><0E>"<0E>$<0E>8<>r"rnzOptional[CapabilityRegistry]<5D>_registry_instancec

<01>8<00>t<00>|<00>d
}t|<00>
atS)z+Get or create the global registry instance.zap-agent)r<>rn)
rps
 r#<00>get_registryr<79>+
s&<00><00><1A>!<21><13><1B>!<21>H<EFBFBD>/<2F><08>9<><1A><1D>r"c

<01><00>d
ay
)z/Reset the global registry (mainly for testing).N)
r<>r!r"r#<00>reset_registryr<79>5
s
<00><00><1E>r"z1.0.0<EFBFBD>c
<01>$<00><00>
<01><02><03><04>d<02>
<01><03><04><00>fd
<01>}|S)z<>
    Decorator to register a function as a capability.
    
    Usage:
        @capability("my_tool", CapabilityType.TOOL, "1.0.0", "Does something")
        def my_tool_function(arg1: str) -> str:
            return f"Result: {arg1}"
    c

<01>^<00><05>t
d<03><05><02><06>d
<01><04><04>
<01>
}
t<00>j|
|<00><02>
|S)N)r1r2r3r4)
r{r!)r/r<>r})<07>funcr<63><00>cap_typer4r<>r1r3s  <20><><EFBFBD><EFBFBD><EFBFBD>r#<00>	decoratorzcapability.<locals>.decoratorK
sD<00><><00><18>
<EFBFBD><15><19><1B>#<23>	
<EFBFBD>
<15>
<EFBFBD><03>	<15><0E><1F><1F><03>T<EFBFBD><1F>2<><13>r")r<>rr`rr!)r1r<>r3r4r<>r<>s````` r#rzrz<
s<00><><00>	<14>	<14><15>r"<00>__main__z
test-agent<6E>file_readerzRead file contents<74>path<74>stringT)r2<00>required<65>
filesystem<EFBFBD>io)r1r2r3r4r9r<<00>
code_analyzerz2.1.0zAnalyze code for issues<65>code<64>analysis)r1r2r3r4r;r<zRegistry stats:z
All capabilities:z  - z (z): r<>z
Query results for 'code' tag: z
Export:r@)rpr5r`rn)r1r0r<>rr3r0r4r0)/r<00>
__future__rr<>rR<00>dataclassesrrr<00>typingrrr	r
rrr
<00>enumrrsrr%r/rhrnr<>rbr<>r<>rrzr<00>registryr<00>cap1<70>cap2r}<00>printr<74>r<>r<>r1r3r4r<>r<>r<>)
<01>
rs
0r#<00><module>r<>
s'<00>


<01>
<04>
#<23><0B><0E>0<>0<>;<3B>;<3B><1D><15><10>
<18>T<EFBFBD>
<18>
<1A>t<EFBFBD>
<1A><0B>)
<1B>)
<1B><0B>)
<1B>X
<0B>
.<2E>
.<2E><0B>
.<2E>G
<19>G
<19>V48<34><12>0<>7<>
<1E>
<1E> .<2E>3<>3<><1A><19>	
<15>

<0A>
<15><1C>
<15><11>
<15><15>	
<15>8<0C>z<EFBFBD><19>!<21>,<2C>/<2F>H<EFBFBD><16>
<1A>
<1B>
 <20>
 <20><17>(<28><1A>X<EFBFBD>4<EFBFBD>@<40>A<><1A>D<EFBFBD>
!<21>
<06>D<EFBFBD><16>
<1C>
<1B>
!<21>
!<21><17>-<2D>#<23>_<EFBFBD><14>j<EFBFBD>
!<21>
<06>D<EFBFBD>
<0A><15><15>d<EFBFBD><1B><0C><15><15>d<EFBFBD><1B>	<09>
<1B>X<EFBFBD>/<2F>/<2F>1<>2<>	<09>
<1F> <20><17> <20> <20>"<22>
D
<01><03>
<0A><04>S<EFBFBD>X<EFBFBD>X<EFBFBD>J<EFBFBD>b<EFBFBD><13><1B><1B>
<0A>S<EFBFBD><13><1F><1F>0A<30>B<>C<>
D
<01>
<1C>&<26><18>*<2A>E<EFBFBD><16>n<EFBFBD>n<EFBFBD>U<EFBFBD>#<23>G<EFBFBD>	<09>,<2C>g<EFBFBD>-F<><11>a<EFBFBD>f<EFBFBD>f<EFBFBD>-F<>,G<>
H<EFBFBD>I<>
<EFBFBD>+<2B><16>	<09>(<28>
<1E>
<1E>
 <20>!<21>M
<1A><>D
.G
s<00>G