index int64 0 731k | package stringlengths 2 98 ⌀ | name stringlengths 1 76 | docstring stringlengths 0 281k ⌀ | code stringlengths 4 8.19k | signature stringlengths 2 42.8k ⌀ | embed_func_code listlengths 768 768 |
|---|---|---|---|---|---|---|
0 | websocket | WebSocket | null | class WebSocket(object):
@classmethod
def is_socket(self, environ):
if 'upgrade' not in environ.get("HTTP_CONNECTION").lower():
return False
if environ.get("HTTP_UPGRADE") != "WebSocket":
return False
if not environ.get("HTTP_ORIGIN"):
return False
... | (environ, socket, rfile) | [
-0.011135046370327473,
-0.039216987788677216,
-0.11918970197439194,
0.02561788447201252,
-0.013432754203677177,
-0.03643062710762024,
-0.034663159400224686,
0.05181799456477165,
-0.037116821855306625,
-0.04019429534673691,
0.01584482751786709,
0.04815829545259476,
0.008078367449343204,
0.0... |
1 | websocket | __init__ | null | def __init__(self, environ, socket, rfile):
# QQQ should reply Bad Request when IOError is raised above
# should only log the error message, traceback is not necessary
self.origin = environ['HTTP_ORIGIN']
self.protocol = environ.get('HTTP_SEC_WEBSOCKET_PROTOCOL', 'unknown')
self.path_info = envi... | (self, environ, socket, rfile) | [
-0.04108428582549095,
-0.035939496010541916,
-0.10785550624132156,
0.00980841089040041,
-0.02004246972501278,
-0.019283706322312355,
-0.020967790856957436,
0.0590355284512043,
-0.05041152983903885,
0.008832195773720741,
0.04315700754523277,
0.08831270784139633,
0.015961799770593643,
0.0338... |
2 | websocket | __repr__ | null | def __repr__(self):
try:
info = ' ' + self.socket._formatinfo()
except Exception:
info = ''
return '<%s at %s%s>' % (type(self).__name__, hex(id(self)), info)
| (self) | [
0.024408552795648575,
-0.017195727676153183,
0.03823239728808403,
0.006221614312380552,
0.046834684908390045,
-0.07320795953273773,
0.012089225463569164,
0.0142220975831151,
0.014363698661327362,
-0.048144496977329254,
-0.02463865466415882,
0.02154112234711647,
-0.026373272761702538,
0.007... |
3 | websocket | _get_challenge | null | def _get_challenge(self):
part1 = self._get_key_value(self.key1)
part2 = self._get_key_value(self.key2)
# This request should have 8 bytes of data in the body
key3 = self.rfile.read(8)
challenge = ""
challenge += struct.pack("!I", part1)
challenge += struct.pack("!I", part2)
challenge +=... | (self) | [
-0.011837348341941833,
-0.009784940630197525,
-0.03544903174042702,
0.08029592782258987,
0.004467136226594448,
-0.03681730479001999,
0.005230037495493889,
-0.015285031870007515,
0.00002579222564236261,
0.016059186309576035,
0.043424613773822784,
0.09117008745670319,
-0.015186012722551823,
... |
4 | websocket | _get_key_value | null | def _get_key_value(self, key_value):
key_number = int(re.sub("\\D", "", key_value))
spaces = re.subn(" ", "", key_value)[1]
if key_number % spaces != 0:
self._reply_400('Invalid key')
raise IOError("key_number %r is not an intergral multiple of spaces %r" % (key_number, spaces))
return k... | (self, key_value) | [
0.05641850829124451,
0.027373693883419037,
-0.09503594040870667,
0.05205906182527542,
0.04908010736107826,
0.020798195153474808,
0.0279912818223238,
-0.026883255690336227,
0.07080468535423279,
-0.06430184096097946,
0.012669642455875874,
0.021706413477659225,
0.01685652881860733,
0.01363235... |
5 | websocket | _message_length | null | def _message_length(self):
# TODO: buildin security agains lengths greater than 2**31 or 2**32
length = 0
while True:
byte_str = self.rfile.read(1)
if not byte_str:
return 0
else:
byte = ord(byte_str)
if byte != 0x00:
length = length * 128 ... | (self) | [
-0.02438482828438282,
0.007201713044196367,
0.015868335962295532,
0.0898963063955307,
0.04178176447749138,
0.007552017457783222,
0.01111875381320715,
-0.006705827545374632,
0.03311968967318535,
-0.026040812954306602,
0.0299896989017725,
0.04280083253979683,
-0.013548137620091438,
-0.008107... |
6 | websocket | _read_until | null | def _read_until(self):
bytes = []
while True:
byte = self.rfile.read(1)
if ord(byte) != 0xff:
bytes.append(byte)
else:
break
return ''.join(bytes)
| (self) | [
-0.03385533019900322,
-0.02092122659087181,
-0.08310925960540771,
0.058140505105257034,
0.017107555642724037,
0.023763492703437805,
0.008913557976484299,
0.021263018250465393,
0.060299187898635864,
-0.0532115139067173,
0.06288960576057434,
0.011584927327930927,
-0.00976803619414568,
0.0283... |
7 | websocket | _reply_400 | null | def _reply_400(self, message):
self._send_reply('400 Bad Request',
[('Content-Length', str(len(message))),
('Content-Type', 'text/plain')],
message)
self.socket = None
self.rfile = None
| (self, message) | [
-0.02454221248626709,
0.03832029551267624,
-0.024057826027274132,
0.03781796991825104,
-0.04542462155222893,
-0.03065982647240162,
-0.019823936745524406,
0.0740572065114975,
0.06634291261434555,
-0.06196549907326698,
0.0227481909096241,
-0.00874585472047329,
0.014056157320737839,
-0.014989... |
8 | websocket | _send_reply | null | def _send_reply(self, status, headers, message=None):
self.status = status
self.headers_sent = True
towrite = ['HTTP/1.1 %s\r\n' % self.status]
for header in headers:
towrite.append("%s: %s\r\n" % header)
towrite.append("\r\n")
if message:
towrite.append(message)
self.socket.... | (self, status, headers, message=None) | [
-0.0509067103266716,
0.02246098965406418,
-0.10590055584907532,
-0.03526977449655533,
0.025362124666571617,
-0.029978396371006966,
-0.07984507828950882,
0.08320236951112747,
0.016914164647459984,
0.0071342382580041885,
-0.016731703653931618,
-0.037057895213365555,
0.03156581148505211,
-0.0... |
9 | websocket | close | null | def close(self):
# XXX implement graceful close with 0xFF frame
if self.socket is not None:
try:
self.socket.close()
except Exception:
pass
self.socket = None
self.rfile = None
| (self) | [
0.007682926952838898,
-0.054943498224020004,
-0.016643404960632324,
0.04507552087306976,
-0.049657080322504044,
-0.057903893291950226,
-0.05441485717892647,
0.09325240552425385,
-0.008537564426660538,
-0.016229301691055298,
-0.006141054909676313,
-0.0436658076941967,
0.03767453506588936,
-... |
10 | websocket | do_handshake | This method is called automatically in the first send() or receive() | def do_handshake(self):
"""This method is called automatically in the first send() or receive()"""
assert not self.handshaked, 'Already did handshake'
if self.key1 is not None:
# version 76
if not self.key1:
message = "Missing HTTP_SEC_WEBSOCKET_KEY1 header in the request"
... | (self) | [
-0.06672488152980804,
-0.039717189967632294,
-0.09143780171871185,
-0.0036539817228913307,
-0.0361514687538147,
-0.01620461419224739,
-0.02319484017789364,
0.055180419236421585,
-0.03968188911676407,
0.009505648165941238,
0.022418148815631866,
-0.00009508681978331879,
0.021747369319200516,
... |
11 | websocket | getpeername | null | def getpeername(self):
return self.socket.getpeername()
| (self) | [
0.012900936417281628,
0.01073470152914524,
0.013269283808767796,
0.05276140943169594,
-0.03658919408917427,
-0.02645086497068405,
0.06865297257900238,
0.008397447876632214,
0.06381183862686157,
-0.039851702749729156,
-0.028239982202649117,
-0.040553316473960876,
-0.04058839753270149,
-0.02... |
12 | websocket | getsockname | null | def getsockname(self):
return self.socket.getsockname()
| (self) | [
0.038244377821683884,
0.020540641620755196,
0.004740148317068815,
0.015342638827860355,
-0.011087278835475445,
-0.006131669040769339,
0.04240996390581131,
-0.005682791117578745,
0.060688260942697525,
-0.03589225932955742,
-0.038244377821683884,
-0.047365572303533554,
-0.03337854519486427,
... |
13 | websocket | receive | null | def receive(self):
if not self.handshaked:
self.do_handshake()
while self.socket is not None:
frame_str = self.rfile.read(1)
if not frame_str:
self.close()
break
else:
frame_type = ord(frame_str)
if (frame_type & 0x80) == 0x00: # most ... | (self) | [
0.006777434144169092,
-0.030777743086218834,
-0.06136929243803024,
0.01589159294962883,
-0.014653408899903297,
-0.03710831329226494,
0.014904769137501717,
0.043308548629283905,
0.019140666350722313,
-0.0334775447845459,
-0.007177749648690224,
0.015016485005617142,
-0.029660584405064583,
0.... |
14 | websocket | send | null | def send(self, message):
if not self.handshaked:
self.do_handshake()
if isinstance(message, str):
pass
elif isinstance(message, unicode):
message = message.encode('utf-8')
else:
raise TypeError("Expected string or unicode: %r" % (message, ))
self.socket.sendall("\x00"... | (self, message) | [
-0.031467147171497345,
0.02515200525522232,
-0.03248046711087227,
0.016737844794988632,
-0.013001234270632267,
-0.05475537106394768,
-0.059749580919742584,
0.08026927709579468,
0.05670962855219841,
-0.037637531757354736,
0.00583562720566988,
0.021080637350678444,
-0.0348690040409565,
0.008... |
15 | builtins | str | str(object='') -> str
str(bytes_or_buffer[, encoding[, errors]]) -> str
Create a new string object from the given object. If encoding or
errors is specified, then the object must expose a data buffer
that will be decoded using the given encoding and error handler.
Otherwise, returns the result of object.__str__() (if ... | from builtins import str
| null | [
-0.014316649176180363,
-0.004014108795672655,
-0.004127926658838987,
-0.003099501831457019,
0.020162004977464676,
0.011243569664657116,
0.03778750076889992,
0.035153429955244064,
0.03827529028058052,
-0.06913616508245468,
0.004442957695573568,
0.029478801414370537,
-0.026275645941495895,
0... |
17 | moscow_yandex_transport | YandexMapsRequester | null | class YandexMapsRequester(object):
def __init__(self, user_agent: str = None):
"""
:type user_agent: set user agent for data requester
"""
self._config = CONFIG
if user_agent is not None:
CONFIG['headers']['User-Agent'] = user_agent
self.set_new_session()... | (user_agent: str = None) | [
0.07295291125774384,
0.005364458542317152,
-0.09431769698858261,
0.002149505540728569,
-0.05966506153345108,
0.018554605543613434,
-0.11084376275539398,
0.04741939529776573,
-0.011510555632412434,
-0.011985121294856071,
-0.007090576458722353,
0.0048945448361337185,
-0.027990097180008888,
0... |
18 | moscow_yandex_transport | __init__ |
:type user_agent: set user agent for data requester
| def __init__(self, user_agent: str = None):
"""
:type user_agent: set user agent for data requester
"""
self._config = CONFIG
if user_agent is not None:
CONFIG['headers']['User-Agent'] = user_agent
self.set_new_session()
| (self, user_agent: Optional[str] = None) | [
-0.02888535149395466,
-0.025036437436938286,
-0.05573521926999092,
-0.03934032842516899,
-0.0070177894085645676,
-0.019004007801413536,
-0.030587755143642426,
0.03512132912874222,
-0.024721862748265266,
-0.00706867640838027,
-0.01147272065281868,
0.026849867776036263,
-0.009872091002762318,
... |
19 | moscow_yandex_transport | get_stop_info | "
get transport data for stop_id in json
| def get_stop_info(self, stop_id):
""""
get transport data for stop_id in json
"""
self._config["params"]["id"] = f"stop__{stop_id}"
req = requests.get(self._config["uri"], params=self._config["params"], cookies=self._config["cookies"],
headers=self._config["headers"])
retu... | (self, stop_id) | [
0.06164545193314552,
0.029862787574529648,
-0.006518849637359381,
-0.019251113757491112,
0.004660061094909906,
-0.008094020187854767,
-0.010725121945142746,
0.05728209763765335,
-0.004481163807213306,
-0.00844308827072382,
-0.08670855313539505,
-0.053581975400447845,
-0.009136861190199852,
... |
20 | moscow_yandex_transport | set_new_session |
Create new http session to Yandex, with valid csrf_token and session_id
| def set_new_session(self):
"""
Create new http session to Yandex, with valid csrf_token and session_id
"""
ya_request = requests.get(url=self._config["init_url"], headers=self._config["headers"])
reply = ya_request.content.decode('utf8')
self._config["params"][CSRF_TOKEN_KEY] = re.search(f'"{CSR... | (self) | [
-0.030743589624762535,
-0.011363360099494457,
-0.01755988597869873,
-0.03578171506524086,
-0.04931477829813957,
0.03392459452152252,
-0.08737652003765106,
0.07634413242340088,
0.018543606624007225,
-0.011528845876455307,
0.02072250284254551,
0.0063987853936851025,
0.009478660300374031,
0.0... |
21 | json | loads | Deserialize ``s`` (a ``str``, ``bytes`` or ``bytearray`` instance
containing a JSON document) to a Python object.
``object_hook`` is an optional function that will be called with the
result of any object literal decode (a ``dict``). The return value of
``object_hook`` will be used instead of the ``dict... | def loads(s, *, cls=None, object_hook=None, parse_float=None,
parse_int=None, parse_constant=None, object_pairs_hook=None, **kw):
"""Deserialize ``s`` (a ``str``, ``bytes`` or ``bytearray`` instance
containing a JSON document) to a Python object.
``object_hook`` is an optional function that will be... | (s, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw) | [
0.013135293498635292,
-0.004011943936347961,
-0.014931323938071728,
-0.018455427139997482,
-0.02184361405670643,
0.06139511987566948,
0.010271352715790272,
0.0801515057682991,
-0.01885346695780754,
-0.009630607441067696,
0.032114967703819275,
0.075608029961586,
-0.02242611162364483,
0.0034... |
26 | pycookiecheat.chrome | chrome_cookies | Retrieve cookies from Chrome/Chromium on OSX or Linux.
Args:
url: Domain from which to retrieve cookies, starting with http(s)
cookie_file: Path to alternate file to search for cookies
browser: Name of the browser's cookies to read ('Chrome' or 'Chromium')
curl_cookie_file: Path to ... | def chrome_cookies(
url: str,
cookie_file: t.Optional[str] = None,
browser: str = "Chrome",
curl_cookie_file: t.Optional[str] = None,
password: t.Optional[t.Union[bytes, str]] = None,
) -> dict:
"""Retrieve cookies from Chrome/Chromium on OSX or Linux.
Args:
url: Domain from which t... | (url: str, cookie_file: Optional[str] = None, browser: str = 'Chrome', curl_cookie_file: Optional[str] = None, password: Union[bytes, str, NoneType] = None) -> dict | [
-0.0022437821608036757,
-0.013052857480943203,
-0.05988230183720589,
0.03348790109157562,
0.0006553493440151215,
0.03223004192113876,
-0.044994208961725235,
-0.0014434439362958074,
-0.002313376637175679,
-0.0028688448946923018,
0.04755116626620293,
0.09254537522792816,
-0.0091658690944314,
... |
29 | pycookiecheat.firefox | firefox_cookies | Retrieve cookies from Chrome/Chromium on OSX or Linux.
Args:
url: Domain from which to retrieve cookies, starting with http(s)
profile_name: Name (or glob pattern) of the Firefox profile to search
for cookies -- if none given it will find the configured
d... | def firefox_cookies(
url: str,
profile_name: Optional[str] = None,
browser: str = "Firefox",
curl_cookie_file: Optional[str] = None,
) -> Dict[str, str]:
"""Retrieve cookies from Chrome/Chromium on OSX or Linux.
Args:
url: Domain from which to retrieve cookies, starting with http(s)
... | (url: str, profile_name: Optional[str] = None, browser: str = 'Firefox', curl_cookie_file: Optional[str] = None) -> Dict[str, str] | [
-0.021233027800917625,
-0.005046120844781399,
-0.08807774633169174,
0.009464986622333527,
-0.016196267679333687,
0.03697992116212845,
-0.035219863057136536,
-0.0013844064669683576,
0.0037611855659633875,
-0.030819719657301903,
0.0506671704351902,
0.0872538834810257,
-0.011693144217133522,
... |
30 | arpeggio | And |
This predicate will succeed if the specified expression matches current
input.
| class And(SyntaxPredicate):
"""
This predicate will succeed if the specified expression matches current
input.
"""
def _parse(self, parser):
c_pos = parser.position
for e in self.nodes:
try:
e.parse(parser)
except NoMatch:
parse... | (*elements, **kwargs) | [
-0.013290684670209885,
-0.05642320215702057,
0.037649787962436676,
-0.006353616248816252,
-0.022394245490431786,
0.02711333893239498,
0.004886407405138016,
0.0001563199912197888,
0.018790574744343758,
-0.05628592148423195,
0.05961502715945244,
0.018155641853809357,
0.0745445266366005,
0.02... |
31 | arpeggio | __init__ | null | def __init__(self, *elements, **kwargs):
if len(elements) == 1:
elements = elements[0]
self.elements = elements
self.rule_name = kwargs.get('rule_name', '')
self.root = kwargs.get('root', False)
nodes = kwargs.get('nodes', [])
if not hasattr(nodes, '__iter__'):
nodes = [nodes]
... | (self, *elements, **kwargs) | [
-0.04748739302158356,
0.03818536549806595,
0.011527999304234982,
-0.054581549018621445,
-0.04075518622994423,
0.05722375959157944,
-0.03340767323970795,
-0.005750426556915045,
0.0006215301691554487,
0.010957933031022549,
0.01874883472919464,
0.06743065267801285,
0.003890926018357277,
0.053... |
32 | arpeggio | _clear_cache |
Clears memoization cache. Should be called on input change and end
of parsing.
Args:
processed (set): Set of processed nodes to prevent infinite loops.
| def _clear_cache(self, processed=None):
"""
Clears memoization cache. Should be called on input change and end
of parsing.
Args:
processed (set): Set of processed nodes to prevent infinite loops.
"""
self._result_cache = {}
if not processed:
processed = set()
for node in ... | (self, processed=None) | [
-0.029383104294538498,
0.041659727692604065,
0.009975853376090527,
0.028785957023501396,
-0.025396274402737617,
0.03175412490963936,
-0.056658633053302765,
0.030278822407126427,
0.0812821313738823,
-0.0010664107976481318,
0.008698136545717716,
0.01988145522773266,
0.027398470789194107,
0.0... |
33 | arpeggio | _parse | null | def _parse(self, parser):
c_pos = parser.position
for e in self.nodes:
try:
e.parse(parser)
except NoMatch:
parser.position = c_pos
raise
parser.position = c_pos
| (self, parser) | [
-0.03182803839445114,
0.004330886527895927,
-0.0503428615629673,
0.0445956289768219,
-0.07529604434967041,
0.055071599781513214,
0.06056420877575874,
0.033901408314704895,
0.005051564425230026,
0.014149836264550686,
0.01226743496954441,
-0.006015499122440815,
0.02602624148130417,
0.0117854... |
34 | arpeggio | parse | null | def parse(self, parser):
if parser.debug:
name = self.name
if name.startswith('__asgn'):
name = "{}[{}]".format(self.name, self._attr_name)
parser.dprint(">> Matching rule {}{} at position {} => {}"
.format(name,
" in {}".format... | (self, parser) | [
0.012238399125635624,
0.019728176295757294,
0.005976537242531776,
0.01964665576815605,
0.02024787664413452,
0.01945304311811924,
0.009476861916482449,
-0.03858000040054321,
0.0008343204972334206,
-0.039639778435230255,
0.015213930048048496,
-0.005410982295870781,
0.03586941212415695,
-0.00... |
35 | arpeggio | ArpeggioError |
Base class for arpeggio errors.
| class ArpeggioError(Exception):
"""
Base class for arpeggio errors.
"""
def __init__(self, message):
self.message = message
def __str__(self):
return repr(self.message)
| (message) | [
-0.004440890159457922,
-0.01787634566426277,
-0.030602198094129562,
0.030188655480742455,
0.024511834606528282,
-0.084287628531456,
-0.02251930721104145,
0.02436145581305027,
0.06488869339227676,
-0.06624210625886917,
0.04673038423061371,
0.02547050267457962,
0.02310202829539776,
0.0396625... |
36 | arpeggio | __init__ | null | def __init__(self, message):
self.message = message
| (self, message) | [
-0.009976469911634922,
0.007533252704888582,
-0.005081183277070522,
-0.004908564500510693,
-0.0019474918954074383,
-0.061576150357723236,
0.011224634945392609,
0.07818294316530228,
0.06412559747695923,
-0.021493228152394295,
-0.011490201577544212,
0.0315493680536747,
-0.03101823478937149,
... |
37 | arpeggio | __str__ | null | def __str__(self):
return repr(self.message)
| (self) | [
-0.007524884771555662,
-0.012334287166595459,
0.047997038811445236,
0.014000605791807175,
0.021388834342360497,
-0.10283568501472473,
0.0238927211612463,
-0.0061671435832977295,
0.10593909025192261,
-0.06862765550613403,
-0.015517043881118298,
-0.0035861122887581587,
-0.041931286454200745,
... |
38 | arpeggio | Combine |
This decorator defines pexpression that represents a lexeme rule.
This rules will always return a Terminal parse tree node.
Whitespaces will be preserved. Comments will not be matched.
| class Combine(Decorator):
"""
This decorator defines pexpression that represents a lexeme rule.
This rules will always return a Terminal parse tree node.
Whitespaces will be preserved. Comments will not be matched.
"""
def _parse(self, parser):
results = []
oldin_lex_rule = pars... | (*elements, **kwargs) | [
-0.05922330543398857,
-0.030612409114837646,
0.08327718824148178,
-0.003739431733265519,
0.026609385386109352,
-0.013304692693054676,
-0.01745961792767048,
-0.06747954338788986,
0.01296515017747879,
-0.005289710126817226,
0.0566856749355793,
0.011553370393812656,
0.03088046982884407,
0.066... |
41 | arpeggio | _parse | null | def _parse(self, parser):
results = []
oldin_lex_rule = parser.in_lex_rule
parser.in_lex_rule = True
c_pos = parser.position
try:
for parser_model_node in self.nodes:
results.append(parser_model_node.parse(parser))
results = flatten(results)
# Create terminal from... | (self, parser) | [
-0.040420107543468475,
0.008437789976596832,
-0.024071024730801582,
-0.007223154883831739,
0.01093633659183979,
0.0470336377620697,
0.025585854426026344,
0.002034398727118969,
0.015120593830943108,
0.018593618646264076,
0.051430340856313705,
-0.005126407835632563,
0.010511444881558418,
0.0... |
43 | arpeggio | CrossRef |
Used for rule reference resolving.
| class CrossRef(object):
'''
Used for rule reference resolving.
'''
def __init__(self, target_rule_name, position=-1):
self.target_rule_name = target_rule_name
self.position = position
| (target_rule_name, position=-1) | [
-0.0085365641862154,
0.016391251236200333,
-0.034705743193626404,
-0.01582302153110504,
-0.05304646119475365,
0.0020194021053612232,
-0.012256285175681114,
-0.0008955086814239621,
0.04437439516186714,
-0.02912834659218788,
-0.009686136618256569,
0.0047337934374809265,
0.04168185964226723,
... |
44 | arpeggio | __init__ | null | def __init__(self, target_rule_name, position=-1):
self.target_rule_name = target_rule_name
self.position = position
| (self, target_rule_name, position=-1) | [
-0.013945668935775757,
0.04656492918729782,
-0.016828341409564018,
-0.05265340581536293,
-0.06557866185903549,
-0.0031675377395004034,
-0.014472883194684982,
0.03557846322655678,
0.016938885673880577,
-0.03537438064813614,
-0.01425179373472929,
0.034830160439014435,
0.03717711195349693,
0.... |
45 | arpeggio | DebugPrinter |
Mixin class for adding debug print support.
Attributes:
debug (bool): If true debugging messages will be printed.
_current_indent(int): Current indentation level for prints.
| class DebugPrinter(object):
"""
Mixin class for adding debug print support.
Attributes:
debug (bool): If true debugging messages will be printed.
_current_indent(int): Current indentation level for prints.
"""
def __init__(self, **kwargs):
self.debug = kwargs.pop("debug", ... | (**kwargs) | [
0.0032352276612073183,
-0.008535398170351982,
-0.021309124305844307,
0.010654562152922153,
0.04514859616756439,
-0.0239659883081913,
-0.025339603424072266,
-0.0039378502406179905,
-0.0020378318149596453,
-0.026442112401127815,
-0.006036681588739157,
-0.019339069724082947,
0.00632134545594453... |
46 | arpeggio | __init__ | null | def __init__(self, **kwargs):
self.debug = kwargs.pop("debug", False)
self.file = kwargs.pop("file", sys.stdout)
self._current_indent = 0
super(DebugPrinter, self).__init__(**kwargs)
| (self, **kwargs) | [
-0.015898343175649643,
0.006948361173272133,
0.02070399932563305,
-0.00010987702262355015,
0.002435894450172782,
-0.023155324161052704,
-0.01061653159558773,
0.02476014941930771,
-0.021144885569810867,
-0.017000557854771614,
-0.020351290702819824,
0.026382610201835632,
-0.04034987464547157,
... |
47 | arpeggio | dprint |
Handle debug message. Print to the stream specified by the 'file'
keyword argument at the current indentation level. Default stream is
stdout.
| def dprint(self, message, indent_change=0):
"""
Handle debug message. Print to the stream specified by the 'file'
keyword argument at the current indentation level. Default stream is
stdout.
"""
if indent_change < 0:
self._current_indent += indent_change
print(("%s%s" % (" " * self... | (self, message, indent_change=0) | [
0.036453042179346085,
0.03736087679862976,
0.0026864041574299335,
0.024965446442365646,
0.03676729276776314,
-0.06473557651042938,
-0.005617225542664528,
-0.006145340856164694,
0.013600057922303677,
-0.01887248083949089,
-0.04588055610656738,
-0.043715719133615494,
-0.012369244359433651,
0... |
48 | arpeggio | Decorator |
Decorator are special kind of parsing expression used to mark
a containing pexpression and give it some special semantics.
For example, decorators are used to mark pexpression as lexical
rules (see :class:Lex).
| class Decorator(ParsingExpression):
"""
Decorator are special kind of parsing expression used to mark
a containing pexpression and give it some special semantics.
For example, decorators are used to mark pexpression as lexical
rules (see :class:Lex).
"""
| (*elements, **kwargs) | [
-0.008225926198065281,
-0.03104683756828308,
0.06291069835424423,
0.005570604931563139,
0.034816280007362366,
-0.023099441081285477,
-0.026627490296959877,
0.016414714977145195,
-0.030322657898068428,
-0.013870805501937866,
0.05466620251536369,
0.017120325937867165,
0.032365214079618454,
0... |
52 | arpeggio | EOF | null | def EOF():
return EndOfFile()
| () | [
-0.0026046994607895613,
-0.005787263158708811,
-0.01718929223716259,
0.015697196125984192,
-0.02559850364923477,
-0.01718929223716259,
-0.019302375614643097,
0.03556881099939346,
-0.020647849887609482,
-0.022424565628170967,
0.0022446129005402327,
-0.05599241703748703,
-0.009694312699139118,... |
53 | arpeggio | Empty |
This predicate will always succeed without consuming input.
| class Empty(SyntaxPredicate):
"""
This predicate will always succeed without consuming input.
"""
def _parse(self, parser):
pass
| (*elements, **kwargs) | [
-0.010340261273086071,
-0.020059781149029732,
0.011312213726341724,
-0.0375712513923645,
-0.013541985303163528,
0.022428402677178383,
-0.000194109627045691,
-0.002213436644524336,
0.05753301829099655,
-0.05024746432900429,
0.027819061651825905,
0.02236306108534336,
0.037309885025024414,
-0... |
56 | arpeggio | _parse | null | def _parse(self, parser):
pass
| (self, parser) | [
-0.02065032161772251,
0.00662621995434165,
-0.03313110023736954,
0.01763077825307846,
-0.044152431190013885,
0.04270976409316063,
0.05606285482645035,
0.0833393931388855,
-0.01914054900407791,
0.008123409934341908,
0.033332403749227524,
-0.0005981421563774347,
-0.0005860849632881582,
0.026... |
58 | arpeggio | EndOfFile |
The Match class that will succeed in case end of input is reached.
| class EndOfFile(Match):
"""
The Match class that will succeed in case end of input is reached.
"""
def __init__(self):
super(EndOfFile, self).__init__("EOF")
@property
def name(self):
return "EOF"
def _parse(self, parser):
c_pos = parser.position
if len(pars... | () | [
0.01780737191438675,
-0.04980388283729553,
-0.006615686696022749,
-0.006584648042917252,
-0.05171941965818405,
-0.03242218494415283,
0.023358874022960663,
0.016228830441832542,
-0.0356147438287735,
-0.04047452285885811,
0.02979719638824463,
-0.019226286560297012,
0.014011777006089687,
0.03... |
59 | arpeggio | __init__ | null | def __init__(self):
super(EndOfFile, self).__init__("EOF")
| (self) | [
-0.015111256390810013,
-0.01410889346152544,
-0.01693067140877247,
-0.002122651319950819,
-0.04541800171136856,
-0.019356559962034225,
0.012938065454363823,
0.08086290955543518,
-0.015717728063464165,
-0.027527082711458206,
0.02506750263273716,
-0.025151735171675682,
0.012836987152695656,
... |
61 | arpeggio | _parse | null | def _parse(self, parser):
c_pos = parser.position
if len(parser.input) == c_pos:
return Terminal(EOF(), c_pos, '', suppress=True)
else:
if parser.debug:
parser.dprint("!! EOF not matched.")
parser._nm_raise(self, c_pos, parser)
| (self, parser) | [
-0.023549366742372513,
-0.022830970585346222,
-0.023742107674479485,
-0.013176431879401207,
-0.0226382315158844,
0.014078807085752487,
0.043208882212638855,
0.03555183485150337,
-0.021464267745614052,
-0.028157614171504974,
0.049306485801935196,
0.0058742002584040165,
-0.009742149151861668,
... |
62 | arpeggio | _parse_comments | Parse comments. | def _parse_comments(self, parser):
"""Parse comments."""
try:
parser.in_parse_comments = True
if parser.comments_model:
try:
while True:
# TODO: Consumed whitespaces and comments should be
# attached to the first match ahe... | (self, parser) | [
-0.06787128001451492,
0.014636634849011898,
-0.02299152873456478,
0.024628696963191032,
-0.006548671051859856,
0.009502691216766834,
0.0839938223361969,
0.06402749568223953,
-0.042815495282411575,
0.014627737924456596,
0.010241195559501648,
-0.040395334362983704,
-0.017991049215197563,
0.0... |
63 | arpeggio | parse | null | def parse(self, parser):
if parser.skipws and not parser.in_lex_rule:
# Whitespace skipping
pos = parser.position
ws = parser.ws
i = parser.input
length = len(i)
while pos < length and i[pos] in ws:
pos += 1
parser.position = pos
if parser.debu... | (self, parser) | [
-0.03486403450369835,
0.0416378378868103,
-0.022541072219610214,
0.0302716251462698,
-0.00474788062274456,
0.03494057431817055,
0.06260983645915985,
0.038308341056108475,
-0.019221141934394836,
-0.02361263334751129,
0.026176728308200836,
-0.033696796745061874,
0.017068451270461082,
-0.0230... |
64 | arpeggio | GrammarError |
Error raised during parser building phase used to indicate error in the
grammar definition.
| class GrammarError(ArpeggioError):
"""
Error raised during parser building phase used to indicate error in the
grammar definition.
"""
| (message) | [
0.012882431969046593,
0.017769478261470795,
0.0040505253709852695,
0.021274063736200333,
-0.01457308605313301,
-0.04487277567386627,
-0.025800084695219994,
-0.014898888766765594,
0.036349061876535416,
-0.058257121592760086,
0.053889598697423935,
-0.0005591486115008593,
0.024373596534132957,
... |
67 | arpeggio | Kwd |
A specialization of StrMatch to specify keywords of the language.
| class Kwd(StrMatch):
"""
A specialization of StrMatch to specify keywords of the language.
"""
def __init__(self, to_match):
super(Kwd, self).__init__(to_match)
self.to_match = to_match
self.root = True
self.rule_name = 'keyword'
| (to_match) | [
0.02232425846159458,
-0.047333624213933945,
0.02494051679968834,
-0.008748114109039307,
-0.046541862189769745,
-0.019811272621154785,
0.013666508719325066,
0.004729059524834156,
0.042169954627752304,
-0.005495003424584866,
-0.0031519890762865543,
0.046886105090379715,
-0.00926878396421671,
... |
68 | arpeggio | __eq__ | null | def __eq__(self, other):
return self.to_match == text(other)
| (self, other) | [
0.07091177254915237,
-0.05394723266363144,
0.03019687905907631,
0.02768612839281559,
-0.04129168763756752,
-0.07891903817653656,
-0.0025764894671738148,
0.03691483661532402,
0.035863034427165985,
-0.01981458067893982,
0.02079852484166622,
-0.017337758094072342,
0.053641870617866516,
0.0378... |
69 | arpeggio | __hash__ | null | def __hash__(self):
return hash(self.to_match)
| (self) | [
0.06711853295564651,
-0.05359514430165291,
-0.007359779439866543,
0.07044123113155365,
-0.03787877410650253,
-0.07243485003709793,
-0.02890748716890812,
-0.006117920856922865,
-0.006994282826781273,
0.006001626141369343,
-0.017477400600910187,
-0.013456933200359344,
0.04093565791845322,
0.... |
70 | arpeggio | __init__ | null | def __init__(self, to_match):
super(Kwd, self).__init__(to_match)
self.to_match = to_match
self.root = True
self.rule_name = 'keyword'
| (self, to_match) | [
0.022983137518167496,
-0.018535858020186424,
0.03591011464595795,
0.01730787754058838,
-0.05977274850010872,
-0.005953213199973106,
0.009633004665374756,
-0.00781592633575201,
0.04062290117144585,
0.02459278516471386,
0.0013119885697960854,
0.021356893703341484,
0.010545692406594753,
0.017... |
71 | arpeggio | __str__ | null | def __str__(self):
return self.to_match
| (self) | [
0.0522305890917778,
-0.054390501230955124,
0.03822388872504234,
0.012664935551583767,
-0.013826706446707249,
-0.07330609112977982,
0.0408419631421566,
-0.0027755682822316885,
0.06541913747787476,
-0.05043066293001175,
-0.029355160892009735,
-0.01791744865477085,
-0.011789517477154732,
0.01... |
72 | arpeggio | __unicode__ | null | def __unicode__(self):
return self.__str__()
| (self) | [
-0.02335135079920292,
-0.02636389061808586,
0.062414512038230896,
0.009412108920514584,
-0.005197048652917147,
-0.04653625935316086,
0.025515053421258926,
-0.027928413823246956,
0.10106158256530762,
-0.05638943240046501,
-0.04314091056585312,
-0.01600308157503605,
-0.018557915464043617,
-0... |
74 | arpeggio | _parse | null | def _parse(self, parser):
c_pos = parser.position
input_frag = parser.input[c_pos:c_pos+len(self.to_match)]
if self.ignore_case:
match = input_frag.lower() == self.to_match.lower()
else:
match = input_frag == self.to_match
if match:
if parser.debug:
parser.dprint(... | (self, parser) | [
0.01833045668900013,
-0.018817521631717682,
-0.014246614649891853,
0.021074874326586723,
-0.04155028611421585,
-0.01478051207959652,
0.09381597489118576,
0.03739150986075401,
-0.06950025260448456,
-0.019370151683688164,
0.030460217967629433,
0.01683180034160614,
0.008294133469462395,
0.002... |
77 | arpeggio | Match |
Base class for all classes that will try to match something from the input.
| class Match(ParsingExpression):
"""
Base class for all classes that will try to match something from the input.
"""
def __init__(self, rule_name, root=False, **kwargs):
super(Match, self).__init__(rule_name=rule_name, root=root, **kwargs)
@property
def name(self):
if self.root:
... | (rule_name, root=False, **kwargs) | [
0.012286120094358921,
-0.02359927073121071,
0.01569151133298874,
0.023389413952827454,
-0.0297995638102293,
-0.01806670054793358,
0.04384084418416023,
0.002036557998508215,
-0.014842548407614231,
-0.06631451845169067,
0.007077873218804598,
0.009352903813123703,
0.03819380700588226,
-0.0129... |
78 | arpeggio | __init__ | null | def __init__(self, rule_name, root=False, **kwargs):
super(Match, self).__init__(rule_name=rule_name, root=root, **kwargs)
| (self, rule_name, root=False, **kwargs) | [
0.011618467047810555,
-0.0017572414362803102,
0.03979221731424332,
-0.0004168280283920467,
-0.08461221307516098,
-0.012354440987110138,
0.004684599116444588,
0.03565753251314163,
0.027917398139834404,
0.011940972879529,
0.016762016341090202,
0.05189857631921768,
0.028479715809226036,
0.038... |
82 | arpeggio | NoMatch |
Exception raised by the Match classes during parsing to indicate that the
match is not successful.
Args:
rules (list of ParsingExpression): Rules that are tried at the position
of the exception.
position (int): A position in the input stream where exception
occurred... | class NoMatch(Exception):
"""
Exception raised by the Match classes during parsing to indicate that the
match is not successful.
Args:
rules (list of ParsingExpression): Rules that are tried at the position
of the exception.
position (int): A position in the input stream whe... | (rules, position, parser) | [
0.02290913090109825,
-0.020248349756002426,
0.019946416839957237,
0.015832586213946342,
-0.03681689873337746,
-0.07001060247421265,
0.026003938168287277,
0.022965742275118828,
0.0214938223361969,
-0.05230981111526489,
0.034099504351615906,
0.035552553832530975,
-0.0033495640382170677,
-0.0... |
83 | arpeggio | __init__ | null | def __init__(self, rules, position, parser):
self.rules = rules
self.position = position
self.parser = parser
| (self, rules, position, parser) | [
-0.01200826931744814,
0.0341448113322258,
-0.03431418165564537,
-0.058296848088502884,
-0.047084610909223557,
0.03148571774363518,
-0.010577100329101086,
0.0069695389829576015,
-0.010687191039323807,
-0.0003638789348769933,
0.020493661984801292,
0.020188797265291214,
0.0002330148417968303,
... |
84 | arpeggio | __str__ | null | def __str__(self):
self.eval_attrs()
return "{} at position {}{} => '{}'."\
.format(self.message,
"{}:".format(self.parser.file_name)
if self.parser.file_name else "",
(self.line, self.col),
self.context)
| (self) | [
0.026909107342362404,
-0.015834445133805275,
0.050209712237119675,
0.0020093766506761312,
0.054127514362335205,
-0.09361482411623001,
0.04890378192067146,
-0.004115409683436155,
0.03371370956301689,
-0.04962547868490219,
-0.006521076895296574,
-0.022114956751465797,
-0.015009645372629166,
... |
86 | arpeggio | eval_attrs |
Call this to evaluate `message`, `context`, `line` and `col`. Called by __str__.
| def eval_attrs(self):
"""
Call this to evaluate `message`, `context`, `line` and `col`. Called by __str__.
"""
def rule_to_exp_str(rule):
if hasattr(rule, '_exp_str'):
# Rule may override expected report string
return rule._exp_str
elif rule.root:
retu... | (self) | [
0.03782946243882179,
0.03445693105459213,
0.041077084839344025,
-0.041077084839344025,
0.017888696864247322,
-0.06902092695236206,
0.05028463527560234,
-0.0036758817732334137,
0.011598655954003334,
-0.02632002718746662,
0.014962266199290752,
0.035991519689559937,
0.02644493617117405,
0.065... |
87 | arpeggio | NonTerminal |
Non-leaf node of the Parse Tree. Represents language syntax construction.
At the same time used in ParseTreeNode navigation expressions.
See test_ptnode_navigation_expressions.py for examples of navigation
expressions.
Attributes:
nodes (list of ParseTreeNode): Children parse tree nodes.
... | class NonTerminal(ParseTreeNode, list):
"""
Non-leaf node of the Parse Tree. Represents language syntax construction.
At the same time used in ParseTreeNode navigation expressions.
See test_ptnode_navigation_expressions.py for examples of navigation
expressions.
Attributes:
nodes (list ... | (rule, nodes, error=False, _filtered=False) | [
0.009248190559446812,
0.016575051471590996,
0.0029465164989233017,
-0.03701188042759895,
0.005897812079638243,
0.0317545086145401,
-0.025101548060774803,
-0.05540311336517334,
0.031257450580596924,
-0.08029436320066452,
0.03773835301399231,
0.01978682540357113,
-0.006327960640192032,
0.000... |
88 | arpeggio | __getattr__ |
Find a child (non)terminal by the rule name.
Args:
rule_name(str): The name of the rule that is referenced from
this node rule.
| def __getattr__(self, rule_name):
"""
Find a child (non)terminal by the rule name.
Args:
rule_name(str): The name of the rule that is referenced from
this node rule.
"""
# Prevent infinite recursion
if rule_name in ['_expr_cache', '_filtered', 'rule', 'rule_name',
... | (self, rule_name) | [
0.02293778955936432,
0.017422493547201157,
0.01802515797317028,
-0.03254390135407448,
-0.002933425595983863,
0.01632673852145672,
-0.022371649742126465,
-0.051756128668785095,
0.03787657245993614,
-0.04576600342988968,
0.026919031515717506,
0.045218128710985184,
0.02673640474677086,
0.0054... |
89 | arpeggio | __init__ | null | def __init__(self, rule, nodes, error=False, _filtered=False):
# Inherit position from the first child node
position = nodes[0].position if nodes else 0
super(NonTerminal, self).__init__(rule, position, error)
self.extend(flatten([nodes]))
self._filtered = _filtered
| (self, rule, nodes, error=False, _filtered=False) | [
-0.03222524747252464,
0.049210455268621445,
0.05612203851342201,
-0.05473972111940384,
-0.049590595066547394,
0.008527163416147232,
-0.02325746975839138,
-0.008436448872089386,
0.048864878714084625,
-0.018246574327349663,
0.04236799106001854,
0.032812729477882385,
0.020682906731963158,
0.0... |
90 | arpeggio | __repr__ | null | def __repr__(self):
return "[ %s ]" % ", ".join([repr(x) for x in self])
| (self) | [
-0.003070969134569168,
-0.02858916111290455,
0.04193752631545067,
-0.009952137246727943,
0.010273173451423645,
-0.04382995516061783,
0.005981420166790485,
-0.047276873141527176,
0.0844157487154007,
-0.00007247085886774585,
-0.025547761470079422,
-0.009571962058544159,
0.00455365190282464,
... |
91 | arpeggio | __str__ | null | def __str__(self):
return " | ".join([text(x) for x in self])
| (self) | [
0.02631305158138275,
-0.06113915145397186,
0.021619100123643875,
-0.004773867316544056,
0.013989323750138283,
-0.05319812521338463,
0.005047260783612728,
-0.04670398309826851,
0.14603407680988312,
-0.005320653785020113,
0.0014290056424215436,
-0.018355203792452812,
0.0062628090381622314,
0... |
93 | arpeggio | flat_str |
Return flatten string representation.
| def flat_str(self):
"""
Return flatten string representation.
"""
return "".join([x.flat_str() for x in self])
| (self) | [
-0.025107938796281815,
-0.037306126207113266,
0.06858092546463013,
-0.0058153169229626656,
-0.013401065953075886,
-0.06492146849632263,
0.006179568357765675,
-0.03683175519108772,
0.12455706298351288,
-0.018534470349550247,
-0.015137613750994205,
-0.023396803066134453,
0.00030018980032764375... |
94 | arpeggio | tree_str | null | def tree_str(self, indent=0):
return '{}\n{}'.format(super(NonTerminal, self).tree_str(indent),
'\n'.join([c.tree_str(indent + 1)
for c in self]))
| (self, indent=0) | [
-0.00897137075662613,
-0.012900122441351414,
0.06945688277482986,
-0.014825643040239811,
0.024107860401272774,
-0.051427800208330154,
-0.026162900030612946,
-0.056643109768629074,
0.05198041349649429,
-0.01257200725376606,
0.01965239644050598,
-0.026421938091516495,
-0.023088974878191948,
... |
95 | arpeggio | visit |
Visitor pattern implementation.
Args:
visitor(PTNodeVisitor): The visitor object.
| def visit(self, visitor):
"""
Visitor pattern implementation.
Args:
visitor(PTNodeVisitor): The visitor object.
"""
if visitor.debug:
visitor.dprint("Visiting {} type:{} str:{}"
.format(self.name, type(self).__name__, text(self)))
children = SemanticAction... | (self, visitor) | [
-0.0035997088998556137,
-0.04074256867170334,
0.0036606062203645706,
-0.014245464466512203,
-0.03444533422589302,
-0.02610916644334793,
0.022969570010900497,
-0.036845140159130096,
0.013216976076364517,
0.011340436525642872,
0.045145221054553986,
-0.0011130678467452526,
0.05369791388511658,
... |
96 | arpeggio | Not |
This predicate will succeed if the specified expression doesn't match
current input.
| class Not(SyntaxPredicate):
"""
This predicate will succeed if the specified expression doesn't match
current input.
"""
def _parse(self, parser):
c_pos = parser.position
old_in_not = parser.in_not
parser.in_not = True
try:
for e in self.nodes:
... | (*elements, **kwargs) | [
0.02581929787993431,
-0.004615641664713621,
0.07858970016241074,
0.0024581386242061853,
-0.049834780395030975,
0.010690250433981419,
-0.0003567285311874002,
-0.013219126500189304,
0.04194751754403114,
-0.05818184092640877,
0.017834767699241638,
0.00037524194340221584,
0.024210013449192047,
... |
99 | arpeggio | _parse | null | def _parse(self, parser):
c_pos = parser.position
old_in_not = parser.in_not
parser.in_not = True
try:
for e in self.nodes:
try:
e.parse(parser)
except NoMatch:
parser.position = c_pos
return
parser.position = c_pos
... | (self, parser) | [
-0.016562046483159065,
0.017697054892778397,
-0.04394753277301788,
0.047071076929569244,
-0.07968668639659882,
0.04917765408754349,
0.06501329690217972,
0.018105657771229744,
-0.0013506602263078094,
-0.03096303530037403,
0.006210767198354006,
-0.025297071784734726,
0.017224891111254692,
-0... |
101 | arpeggio | OneOrMore |
OneOrMore will try to match parser expression specified one or more times.
| class OneOrMore(Repetition):
"""
OneOrMore will try to match parser expression specified one or more times.
"""
def _parse(self, parser):
results = []
first = True
if self.eolterm:
# Remember current eolterm and set eolterm of
# this repetition
... | (*elements, **kwargs) | [
-0.012550849467515945,
-0.031394802033901215,
0.009209848940372467,
0.02220262959599495,
-0.02172534354031086,
0.0073669953271746635,
0.032862015068531036,
-0.03652120381593704,
0.03003365360200405,
-0.028159864246845245,
0.05989053472876549,
0.03526611998677254,
0.03592017665505409,
0.028... |
102 | arpeggio | __init__ | null | def __init__(self, *elements, **kwargs):
super(Repetition, self).__init__(*elements, **kwargs)
self.eolterm = kwargs.get('eolterm', False)
self.sep = kwargs.get('sep', None)
| (self, *elements, **kwargs) | [
-0.014996781013906002,
0.0034398059360682964,
0.0021420903503894806,
-0.01549524161964655,
-0.05293992534279823,
-0.0031368625350296497,
-0.007545658387243748,
-0.008216001093387604,
0.018322713673114777,
0.045617714524269104,
0.025043334811925888,
0.0435551218688488,
0.027398129925131798,
... |
104 | arpeggio | _parse | null | def _parse(self, parser):
results = []
first = True
if self.eolterm:
# Remember current eolterm and set eolterm of
# this repetition
old_eolterm = parser.eolterm
parser.eolterm = self.eolterm
# Prefetching
append = results.append
p = self.nodes[0].parse
sep = ... | (self, parser) | [
-0.033073700964450836,
0.019352838397026062,
-0.07899889349937439,
0.018105488270521164,
-0.01622501201927662,
0.056508779525756836,
0.048382099717855453,
0.015497391112148762,
0.02262241020798683,
0.001475323224440217,
0.06036422774195671,
-0.01109386421740055,
-0.01267195213586092,
0.003... |
106 | arpeggio | Optional |
Optional will try to match parser expression specified and will not fail
in case match is not successful.
| class Optional(Repetition):
"""
Optional will try to match parser expression specified and will not fail
in case match is not successful.
"""
def _parse(self, parser):
result = None
c_pos = parser.position
try:
result = [self.nodes[0].parse(parser)]
excep... | (*elements, **kwargs) | [
0.0072034671902656555,
-0.007490388583391905,
0.00846852920949459,
-0.0037125893868505955,
-0.030135445296764374,
-0.005364561453461647,
0.03957776725292206,
-0.029283376410603523,
0.03888220340013504,
-0.0396125465631485,
0.06806124001741409,
0.017441345378756523,
0.017893463373184204,
-0... |
109 | arpeggio | _parse | null | def _parse(self, parser):
result = None
c_pos = parser.position
try:
result = [self.nodes[0].parse(parser)]
except NoMatch:
parser.position = c_pos # Backtracking
return result
| (self, parser) | [
-0.032378166913986206,
-0.0030214544385671616,
-0.051174346357584,
0.015006482601165771,
-0.03511964902281761,
0.058377455919981,
0.060276784002780914,
0.02988753840327263,
0.03646351397037506,
-0.008094541728496552,
0.04318283125758171,
-0.00004927501504425891,
-0.021609334275126457,
-0.0... |
111 | arpeggio | OrderedChoice |
Will match one of the parser expressions specified. Parser will try to
match expressions in the order they are defined.
| class OrderedChoice(Sequence):
"""
Will match one of the parser expressions specified. Parser will try to
match expressions in the order they are defined.
"""
def _parse(self, parser):
result = None
match = False
c_pos = parser.position
if self.ws is not None:
... | (*elements, **kwargs) | [
0.0010942205553874373,
0.006109679117798805,
-0.02302015759050846,
-0.04665083438158035,
-0.00938224047422409,
0.009489978663623333,
0.04661491885781288,
-0.0012726627755910158,
0.025228798389434814,
-0.06123146414756775,
0.026988530531525612,
0.05052942410111427,
0.009750347584486008,
-0.... |
112 | arpeggio | __init__ | null | def __init__(self, *elements, **kwargs):
super(Sequence, self).__init__(*elements, **kwargs)
self.ws = kwargs.pop('ws', None)
self.skipws = kwargs.pop('skipws', None)
| (self, *elements, **kwargs) | [
-0.03280884027481079,
0.04515661671757698,
-0.04407258704304695,
-0.048882968723773956,
-0.052338313311338425,
0.032842714339494705,
-0.028997795656323433,
0.04654552787542343,
0.04959436133503914,
0.05006862431764603,
-0.004725692328065634,
0.049560487270355225,
0.02098613977432251,
0.050... |
114 | arpeggio | _parse | null | def _parse(self, parser):
result = None
match = False
c_pos = parser.position
if self.ws is not None:
old_ws = parser.ws
parser.ws = self.ws
if self.skipws is not None:
old_skipws = parser.skipws
parser.skipws = self.skipws
try:
for e in self.nodes:
... | (self, parser) | [
-0.028918320313096046,
0.006832717917859554,
-0.057109855115413666,
0.02671884372830391,
-0.04670538008213043,
0.0391506627202034,
0.061700064688920975,
0.05469999834895134,
0.019441450014710426,
0.0036100083962082863,
0.04345398396253586,
-0.02780901826918125,
-0.0001408291864208877,
-0.0... |
116 | collections | OrderedDict | Dictionary that remembers insertion order | class OrderedDict(dict):
'Dictionary that remembers insertion order'
# An inherited dict maps keys to values.
# The inherited dict provides __getitem__, __len__, __contains__, and get.
# The remaining methods are order-aware.
# Big-O running times for all methods are the same as regular dictionaries... | null | [
0.024522457271814346,
0.027011176571249962,
-0.06758157908916473,
0.011113414540886879,
-0.0021923785097897053,
0.009831510484218597,
-0.05758379399776459,
0.010898870415985584,
0.043359480798244476,
-0.07457573711872101,
-0.045011475682258606,
0.013848859816789627,
0.0438314788043499,
0.0... |
117 | arpeggio | PTNodeVisitor |
Base class for all parse tree visitors.
| class PTNodeVisitor(DebugPrinter):
"""
Base class for all parse tree visitors.
"""
def __init__(self, defaults=True, **kwargs):
"""
Args:
defaults(bool): If the default visit method should be applied in
case no method is defined.
"""
self.for_s... | (defaults=True, **kwargs) | [
0.005401585716754198,
-0.002232098486274481,
0.015480833128094673,
-0.004352824296802282,
-0.032261017709970474,
-0.018571430817246437,
0.028251592069864273,
-0.002120725577697158,
0.03324481099843979,
-0.06340830028057098,
0.04146784171462059,
-0.006914400961250067,
-0.024947529658675194,
... |
118 | arpeggio | __init__ |
Args:
defaults(bool): If the default visit method should be applied in
case no method is defined.
| def __init__(self, defaults=True, **kwargs):
"""
Args:
defaults(bool): If the default visit method should be applied in
case no method is defined.
"""
self.for_second_pass = []
self.defaults = defaults
super(PTNodeVisitor, self).__init__(**kwargs)
| (self, defaults=True, **kwargs) | [
-0.009669993072748184,
-0.022516770288348198,
0.028102325275540352,
0.011005289852619171,
-0.07952434569597244,
0.012131128460168839,
-0.016154473647475243,
0.01897343248128891,
0.009067799896001816,
0.015883922576904297,
0.03471771627664566,
0.03456062451004982,
-0.002251676982268691,
0.0... |
120 | arpeggio | visit__default__ |
Called if no visit method is defined for the node.
Args:
node(ParseTreeNode):
children(processed children ParseTreeNode-s):
| def visit__default__(self, node, children):
"""
Called if no visit method is defined for the node.
Args:
node(ParseTreeNode):
children(processed children ParseTreeNode-s):
"""
if isinstance(node, Terminal):
# Default for Terminal is to convert to string unless suppress flag
... | (self, node, children) | [
-0.001998333726078272,
-0.022265203297138214,
0.056688256561756134,
-0.011586252599954605,
-0.03582030162215233,
-0.01416299119591713,
0.024442728608846664,
0.026819860562682152,
0.06866464763879776,
-0.057377807796001434,
0.04580063000321388,
0.023626156151294708,
-0.015669113025069237,
-... |
121 | arpeggio | ParseTreeNode |
Abstract base class representing node of the Parse Tree.
The node can be terminal(the leaf of the parse tree) or non-terminal.
Attributes:
rule (ParsingExpression): The rule that created this node.
rule_name (str): The name of the rule that created this node if
root rule or emp... | class ParseTreeNode(object):
"""
Abstract base class representing node of the Parse Tree.
The node can be terminal(the leaf of the parse tree) or non-terminal.
Attributes:
rule (ParsingExpression): The rule that created this node.
rule_name (str): The name of the rule that created this ... | (rule, position, error) | [
-0.013159584254026413,
0.01258290745317936,
-0.001381425536237657,
0.000578154344111681,
0.008324004709720612,
0.004119460470974445,
0.008872320875525475,
-0.007005210034549236,
0.01213858276605606,
-0.07767180353403091,
0.050898853689432144,
-0.00010362168541178107,
0.01213858276605606,
0... |
122 | arpeggio | __init__ | null | def __init__(self, rule, position, error):
assert rule
assert rule.rule_name is not None
self.rule = rule
self.rule_name = rule.rule_name
self.position = position
self.error = error
self.comments = None
| (self, rule, position, error) | [
-0.03471238911151886,
0.0687619298696518,
0.0018817080417647958,
-0.03408442810177803,
-0.04448070004582405,
-0.017417246475815773,
0.0079236701130867,
0.018542347475886345,
0.0018130246317014098,
-0.05644688010215759,
0.021472839638590813,
0.03047364018857479,
0.02862463891506195,
0.03820... |
123 | arpeggio | tree_str | null | def tree_str(self, indent=0):
return '{}{} [{}-{}]'.format(' ' * indent, self.rule.name,
self.position, self.position_end)
| (self, indent=0) | [
0.011475485749542713,
0.03272978961467743,
0.055262863636016846,
-0.03383304178714752,
0.02084476500749588,
-0.04008479788899422,
-0.005616552196443081,
-0.04108775407075882,
0.02208174392580986,
-0.022633368149399757,
0.01032208651304245,
-0.02465599589049816,
-0.013431249186396599,
0.026... |
125 | arpeggio | Parser |
Abstract base class for all parsers.
Attributes:
comments_model: parser model for comments.
comments(list): A list of ParseTreeNode for matched comments.
sem_actions(dict): A dictionary of semantic actions keyed by the
rule name.
parse_tree(NonTerminal): The parse t... | class Parser(DebugPrinter):
"""
Abstract base class for all parsers.
Attributes:
comments_model: parser model for comments.
comments(list): A list of ParseTreeNode for matched comments.
sem_actions(dict): A dictionary of semantic actions keyed by the
rule name.
p... | (skipws=True, ws=None, reduce_tree=False, autokwd=False, ignore_case=False, memoization=False, **kwargs) | [
0.016667991876602173,
0.013366344384849072,
-0.013036179356276989,
0.026264067739248276,
0.00934579037129879,
-0.013408945873379707,
-0.019958987832069397,
-0.011545113287866116,
-0.019958987832069397,
-0.07314745336771011,
0.012173491530120373,
-0.001209494424983859,
0.009904940612614155,
... |
126 | arpeggio | __init__ |
Args:
skipws (bool): Should the whitespace skipping be done. Default is
True.
ws (str): A string consisting of whitespace characters.
reduce_tree (bool): If true non-terminals with single child will be
eliminated from the parse tree. Default ... | def __init__(self, skipws=True, ws=None, reduce_tree=False, autokwd=False,
ignore_case=False, memoization=False, **kwargs):
"""
Args:
skipws (bool): Should the whitespace skipping be done. Default is
True.
ws (str): A string consisting of whitespace characters.
... | (self, skipws=True, ws=None, reduce_tree=False, autokwd=False, ignore_case=False, memoization=False, **kwargs) | [
0.007551553193479776,
0.01457416731864214,
-0.00006423572631319985,
0.010890482924878597,
-0.021780965849757195,
0.009572857059538364,
0.02646585740149021,
0.007523217238485813,
-0.03239753469824791,
-0.03354986384510994,
0.006838429719209671,
0.04076610878109932,
-0.03328539431095123,
0.0... |
127 | arpeggio | _clear_caches |
Clear memoization caches if packrat parser is used.
| def _clear_caches(self):
"""
Clear memoization caches if packrat parser is used.
"""
self.parser_model._clear_cache()
if self.comments_model:
self.comments_model._clear_cache()
| (self) | [
-0.036129217594861984,
-0.009107536636292934,
0.026216251775622368,
0.03802330046892166,
-0.02920784242451191,
-0.012240741401910782,
-0.02936715818941593,
0.048821352422237396,
0.02041008695960045,
0.003923144191503525,
0.013364801183342934,
-0.0065496377646923065,
-0.000784407602623105,
... |
128 | arpeggio | _nm_raise |
Register new NoMatch object if the input is consumed
from the last NoMatch and raise last NoMatch.
Args:
args: A NoMatch instance or (value, position, parser)
| def _nm_raise(self, *args):
"""
Register new NoMatch object if the input is consumed
from the last NoMatch and raise last NoMatch.
Args:
args: A NoMatch instance or (value, position, parser)
"""
rule, position, parser = args
if self.nm is None or not parser.in_parse_comments:
... | (self, *args) | [
0.009480617009103298,
0.020035523921251297,
0.06202239170670509,
0.039999429136514664,
-0.06900528073310852,
-0.02977576106786728,
0.0286298505961895,
0.007622988894581795,
0.019176091998815536,
-0.06127038970589638,
0.017591511830687523,
-0.005420692730695009,
0.05579150468111038,
-0.0363... |
129 | arpeggio | context |
Returns current context substring, i.e. the substring around current
position.
Args:
length(int): If given used to mark with asterisk a length chars
from the current position.
position(int): The position in the input stream.
| def context(self, length=None, position=None):
"""
Returns current context substring, i.e. the substring around current
position.
Args:
length(int): If given used to mark with asterisk a length chars
from the current position.
position(int): The position in the input stream.
... | (self, length=None, position=None) | [
0.043570324778556824,
-0.018046172335743904,
0.041419126093387604,
-0.05487265810370445,
0.07341394573450089,
-0.030611908063292503,
0.015015712939202785,
-0.014623033814132214,
0.08830161392688751,
-0.048965394496917725,
-0.00728590739890933,
-0.02424367517232895,
-0.024926595389842987,
0... |
131 | arpeggio | getASG |
Creates Abstract Semantic Graph (ASG) from the parse tree.
Args:
sem_actions (dict): The semantic actions dictionary to use for
semantic analysis. Rule names are the keys and semantic action
objects are values.
defaults (bool): If True a default ... | def getASG(self, sem_actions=None, defaults=True):
"""
Creates Abstract Semantic Graph (ASG) from the parse tree.
Args:
sem_actions (dict): The semantic actions dictionary to use for
semantic analysis. Rule names are the keys and semantic action
objects are values.
de... | (self, sem_actions=None, defaults=True) | [
0.0213755015283823,
0.007098297588527203,
-0.008411743678152561,
0.002162206918001175,
0.027008619159460068,
0.0012482476886361837,
-0.04442007467150688,
0.0026197792030870914,
0.042106132954359055,
-0.034898776561021805,
0.0238601416349411,
0.03230033442378044,
0.0025628788862377405,
0.02... |
132 | arpeggio | parse |
Parses input and produces parse tree.
Args:
_input(str): An input string to parse.
file_name(str): If input is loaded from file this can be
set to file name. It is used in error messages.
| def parse(self, _input, file_name=None):
"""
Parses input and produces parse tree.
Args:
_input(str): An input string to parse.
file_name(str): If input is loaded from file this can be
set to file name. It is used in error messages.
"""
self.position = 0 # Input position... | (self, _input, file_name=None) | [
-0.014961645007133484,
0.008483551442623138,
-0.02887858636677265,
0.014299377799034119,
-0.034699078649282455,
-0.011417116038501263,
-0.02865472249686718,
0.03988528251647949,
-0.04671316593885422,
-0.08148686587810516,
0.01843155361711979,
0.008236367255449295,
-0.02115524373948574,
0.0... |
133 | arpeggio | parse_file |
Parses content from the given file.
Args:
file_name(str): A file name.
| def parse_file(self, file_name):
"""
Parses content from the given file.
Args:
file_name(str): A file name.
"""
with codecs.open(file_name, 'r', 'utf-8') as f:
content = f.read()
return self.parse(content, file_name=file_name)
| (self, file_name) | [
-0.005220502149313688,
-0.058818548917770386,
-0.0429033599793911,
0.022270582616329193,
-0.03795434162020683,
0.01840749941766262,
-0.006115064024925232,
0.04087390378117561,
0.0565042570233345,
-0.020312337204813957,
0.01766870729625225,
0.014686834998428822,
-0.026062455028295517,
0.049... |
134 | arpeggio | pos_to_linecol |
Calculate (line, column) tuple for the given position in the stream.
| def pos_to_linecol(self, pos):
"""
Calculate (line, column) tuple for the given position in the stream.
"""
if not self.line_ends:
try:
# TODO: Check this implementation on Windows.
self.line_ends.append(self.input.index("\n"))
while True:
try:... | (self, pos) | [
0.010561449453234673,
-0.003563291858881712,
-0.0047539579682052135,
0.041096486151218414,
0.030648227781057358,
-0.014244460500776768,
0.04217614233493805,
0.09493985027074814,
0.0030147582292556763,
-0.0024270436260849237,
0.0008113726507872343,
-0.014209632761776447,
0.0003436497936490923... |
135 | arpeggio | ParserPython | null | class ParserPython(Parser):
def __init__(self, language_def, comment_def=None, syntax_classes=None,
*args, **kwargs):
"""
Constructs parser from python statements and expressions.
Args:
language_def (python function): A python function that defines
... | (language_def, comment_def=None, syntax_classes=None, *args, **kwargs) | [
0.0019864856731146574,
-0.03709803521633148,
-0.005660402588546276,
0.02115524560213089,
-0.01754114031791687,
0.023496780544519424,
-0.010516539216041565,
-0.01625838689506054,
0.007752512115985155,
-0.07289295643568039,
0.018874796107411385,
0.0018821348203346133,
0.019505992531776428,
0... |
136 | arpeggio | __init__ |
Constructs parser from python statements and expressions.
Args:
language_def (python function): A python function that defines
the root rule of the grammar.
comment_def (python function): A python function that defines
the root rule of the commen... | def __init__(self, language_def, comment_def=None, syntax_classes=None,
*args, **kwargs):
"""
Constructs parser from python statements and expressions.
Args:
language_def (python function): A python function that defines
the root rule of the grammar.
comment_def (pyt... | (self, language_def, comment_def=None, syntax_classes=None, *args, **kwargs) | [
0.0088828569278121,
-0.021396059542894363,
0.02678183652460575,
0.014934963546693325,
-0.029998598620295525,
0.005330633372068405,
-0.02159825526177883,
0.028399407863616943,
-0.03512703627347946,
-0.031799983233213425,
0.01658010669052601,
0.006824129726737738,
-0.028160449117422104,
0.07... |
138 | arpeggio | _from_python |
Create parser model from the definition given in the form of python
functions returning lists, tuples, callables, strings and
ParsingExpression objects.
Returns:
Parser Model (PEG Abstract Semantic Graph)
| def _from_python(self, expression):
"""
Create parser model from the definition given in the form of python
functions returning lists, tuples, callables, strings and
ParsingExpression objects.
Returns:
Parser Model (PEG Abstract Semantic Graph)
"""
__rule_cache = {"EndOfFile": EndOfF... | (self, expression) | [
0.00931098498404026,
-0.029538296163082123,
-0.008654029108583927,
0.015895357355475426,
-0.023334266617894173,
0.04789353162050247,
0.006080542225390673,
-0.02181289531290531,
0.023393539711833,
-0.06484594941139221,
0.007646368350833654,
0.019669147208333015,
0.015529833734035492,
0.0216... |
140 | arpeggio | _parse | null | def _parse(self):
return self.parser_model.parse(self)
| (self) | [
0.009995485655963421,
-0.01713148131966591,
-0.03100467287003994,
0.008748170919716358,
-0.027339095249772072,
0.0036083024460822344,
0.05909046158194542,
0.04398692399263382,
0.018395766615867615,
0.012515570037066936,
0.022468630224466324,
-0.0075772227719426155,
-0.008892418816685677,
0... |
143 | arpeggio | errors | null | def errors(self):
pass
| (self) | [
-0.02931283786892891,
-0.0007189589668996632,
0.03275556489825249,
0.05263400450348854,
-0.01214885525405407,
-0.014706073328852654,
-0.0006336149526759982,
-0.0024289435241371393,
0.10857832431793213,
-0.009517154656350613,
0.03965757042169571,
-0.02138463407754898,
0.05773188918828964,
-... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.