llparse 0.1.0__py3-none-any.whl

llparse/tire.py

@@ -0,0 +1,158 @@
+from .pybuilder.main_code import Node, Edge
+from typing import Optional
+
+from dataclasses import dataclass
+
+@dataclass
+class IEdge:
+    # NOTE THIS SHOULD BE STRICTLY BYTES !!!
+    key: bytes
+    node: Node 
+    noAdvance:bool
+    value:Optional[int] = None 
+
+    def __lt__(self,object):
+        return self.key < object.key
+
+# TODO RENAME TO TRIE!
+
+class TireNode:
+    """Mainly Used as an Abstract Object for typing"""
+    def __init__(self) -> None:
+        return 
+
+class TireSequence(TireNode):
+    def __init__(self,select:bytes,child:TireNode) -> None:
+        self.select = select
+        self.child = child
+        
+
+class ITireSingleChild:
+    def __init__(self,key:int,noAdvance:bool,node:TireNode) -> None:
+        self.key = key
+        self.noAdvance = noAdvance
+        self.node = node 
+
+class TireEmpty(TireNode):
+    def __init__(self,node:Node,value:int) -> None:
+        self.node = node 
+        self.value = value 
+
+class TireSingle(TireNode):
+    def __init__(self,children:list[ITireSingleChild],otherwise:Optional[TireEmpty] = None) -> None:
+        self.children = children
+        self.otherwise = otherwise 
+        
+
+
+
+
+# TODO Retry making Tire....
+
+class Tire:
+    def __init__(self,name:str) -> None:
+        self.name = name 
+    
+    def build(self,edges:list[Edge]):
+        if len(edges) == 0:
+            return None 
+        
+        internalEdges: list[IEdge] = []
+        
+        for edge in edges:
+            key = str(edge.key) if isinstance(edge.key,int) else edge.key 
+            internalEdges.append(IEdge(key.encode("utf-8") if isinstance(key,str) else key ,edge.node,edge.noAdvance,edge.value))
+        return self.level(internalEdges,[])
+        
+    def level(self,edges:list[IEdge],path:list[bytes]):
+        first = edges[0].key
+        last = edges[-1].key
+
+        if len(edges) == 1 and len(edges[0].key) == 0:
+            return TireEmpty(edges[0].node,edges[0].value)
+        
+        i = 0 
+        for i in range(len(first)):
+            if first[i] != last[i]:
+                break
+
+        if i > 1:
+            # NOTE I think Idutny intended for these sequences 
+            # to advance otherwise not having this would case a recursion error
+            # This is why first[1:i] is used and not first[0:count] like in typescript...
+            return self.sequence(edges,first[: i + 1 ],path)
+
+        return self.single(edges,path) 
+
+    def Slice(self,edges:list[IEdge],off:int):
+        slice = [IEdge(edge.key[off:],edge.node,edge.noAdvance,edge.value) for edge in edges]
+        return sorted(slice, key = lambda k: k.key)
+
+
+    def sequence(self,edges:list[IEdge],prefix:bytes,path:list[bytes]):
+        sliced = self.Slice(edges,len(prefix))
+        assert not any([edge.noAdvance for edge in edges])
+        child = self.level(sliced,path + [prefix])
+        return TireSequence(prefix,child)
+    
+    def single(self,edges:list[IEdge],path:list[bytes]):
+
+        if len(edges[0].key) == 0:
+            if len(path) == 0:
+                AssertionError(f'Empty root entry at "{self.name}"')
+            if not (len(edges) == 1 or len(edges[1].key) != 0):
+                err = f'Duplicate entries in "{self.name}" at: [' + (b", ".join(path).decode("utf-8")) + ']'
+                
+                raise AssertionError(err)
+
+
+        keys : dict[int,list[IEdge]] = {} 
+
+        for edge in edges:
+            if len(edge.key) == 0:
+                otherwise = TireEmpty(edge.node,edge.value)
+                continue
+
+            key = edge.key[0]
+
+            if keys.get(key):
+                keys[key].append(edge)
+            else:
+                keys[key] = [edge]
+        
+   
+        otherwise = None 
+        children : list[ITireSingleChild] = []
+
+        for key, subEdges in keys.items():
+            # TODO LOG FUNCTION's ARGUMENTS TO DETERMINE WEATHER OR NOT IT'S the Problem...
+            # I think this maybe the problem now that I think about it...
+            sliced = self.Slice(subEdges, 1)
+   
+            
+            subPath = path + [chr(key).encode("utf-8")]
+
+            noAdvance = any([e.noAdvance for e in subEdges])
+            allSame = all([e.noAdvance == noAdvance for e in subEdges])
+           
+            if not (allSame or len(subEdges) == 0):
+                err = f'Conflicting `.peek` and `.match` entries in "{self.name}" at: [' + (b", ".join(subPath).decode("utf-8")) + ']'
+                raise TypeError(err)
+            child = ITireSingleChild(key,noAdvance,self.level(sliced,subPath))
+            children.append(child)
+
+       
+        return TireSingle(children,otherwise)
+
+
+
+
+def test():
+    t = b"data-to-buffer"
+
+    for _ in range(2):
+        t = t[1:4]
+        print(t)
+
+if __name__ == "__main__":
+    test()

llparse/trie.py

@@ -0,0 +1,165 @@
+from dataclasses import dataclass
+from functools import total_ordering
+from typing import Optional
+
+from .pybuilder.main_code import Edge, Node
+
+
+@total_ordering
+@dataclass
+class IEdge:
+    # NOTE THIS SHOULD BE STRICTLY BYTES !!!
+    key: bytes
+    node: Node
+    noAdvance: bool
+    value: Optional[int] = None
+
+    def __lt__(self, object: "IEdge"):
+        return self.key < object.key
+
+
+
+@dataclass
+class TrieNode:
+    """Mainly Used as an Abstract Object for typing"""
+
+
+@dataclass
+class TrieSequence(TrieNode):
+    select: bytes
+    child: TrieNode
+
+
+@dataclass
+class ITrieSingleChild:
+    key: int
+    noAdvance: bool
+    node: TrieNode
+
+
+@dataclass
+class TrieEmpty(TrieNode):
+    node: Node
+    value: int
+
+
+@dataclass
+class TrieSingle(TrieNode):
+    children: list[ITrieSingleChild]
+    otherwise: Optional[TrieEmpty] = None
+
+
+@dataclass
+class Trie:
+    name: str
+
+    def build(self, edges: list[Edge]):
+        if not edges:
+            return None
+        internalEdges: list[IEdge] = []
+
+        for edge in edges:
+            key = str(edge.key) if isinstance(edge.key, int) else edge.key
+            internalEdges.append(
+                IEdge(
+                    key=key.encode("utf-8") if isinstance(key, str) else key,
+                    noAdvance=edge.noAdvance,
+                    node=edge.node,
+                    value=edge.value,
+                )
+            )
+
+        return self.level(internalEdges)
+
+    def level(self, edges: list[IEdge], path: list[bytes] = []):
+        first = edges[0].key
+        last = edges[-1].key
+        # print("level",edges, first)
+        if len(edges) == 1 and len(edges[0].key) == 0:
+            return TrieEmpty(edges[0].node, edges[0].value)
+
+        i = 0
+        # print(first)
+        for i in range(len(first)):
+            if first[i] != last[i]:
+                break
+
+        if i > 1:
+            # NOTE I think Indutny intended for these sequences
+            # to advance otherwise not having this would result in a recursion error
+            # This is why first[:i] is used and not first[0:count] like in typescript...
+            return self.sequence(edges, first[: i + 1], path)
+
+        return self.single(edges, path)
+
+    def Slice(self, edges: list[IEdge], off: int):
+        _slice = [
+            IEdge(edge.key[off:], edge.node, edge.noAdvance, edge.value)
+            for edge in edges
+        ]
+        return sorted(_slice, key=lambda k: k.key)
+
+    def sequence(self, edges: list[IEdge], prefix: bytes, path: list[bytes]):
+        sliced = self.Slice(edges, len(prefix))
+        assert not any([edge.noAdvance for edge in edges])
+        child = self.level(sliced, path + [prefix])
+        return TrieSequence(prefix, child)
+
+    def single(self, edges: list[IEdge], path: list[bytes]):
+        if not len(edges[0].key):
+            assert not path, f'Empty root entry at "{self.name}"'
+            assert not (len(edges) == 1 or len(edges[1].key) != 0), (
+                f'Duplicate entries in "{self.name}" at: ['
+                + (b", ".join(path).decode("utf-8"))
+                + "]"
+            )
+
+        keys: dict[int, list[IEdge]] = {}
+        otherwise = None
+        for edge in edges:
+            if not len(edge.key):
+                otherwise = TrieEmpty(edge.node, edge.value)
+                continue
+
+            key = edge.key[0]
+
+            if keys.get(key):
+                keys[key].append(edge)
+            else:
+                keys[key] = [edge]
+
+        children: list[ITrieSingleChild] = []
+
+        for key, subEdges in keys.items():
+            # TODO LOG FUNCTION's ARGUMENTS TO DETERMINE WEATHER OR NOT IT'S the Problem...
+            # I think this maybe the problem now that I think about it...
+            sliced = self.Slice(subEdges, 1)
+
+            subPath = path + [chr(key).encode("utf-8")]
+
+            noAdvance = any([e.noAdvance for e in subEdges])
+            allSame = all([e.noAdvance == noAdvance for e in subEdges])
+
+            if not (allSame or len(subEdges) == 0):
+                err = (
+                    f'Conflicting `.peek` and `.match` entries in "{self.name}" at: ['
+                    + (b", ".join(subPath).decode("utf-8"))
+                    + "]"
+                )
+                raise TypeError(err)
+            child = ITrieSingleChild(key, noAdvance, self.level(sliced, subPath))
+            children.append(child)
+
+        return TrieSingle(children, otherwise)
+
+
+# def test():
+#     t = b"data-to-buffer"
+
+#     for _ in range(2):
+#         t = t[1:4]
+#         print(t)
+
+
+# if __name__ == "__main__":
+#     test()

llparse-0.1.0.dist-info/METADATA

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: llparse
+Version: 0.1.0
+Summary: A Parody of llparse written for writing C Parsers with Python
+Author-email: Vizonex <VizonexBusiness@gmail.com>
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# pyllparse
+A python parody of the typescript library llparse.
+
+I take no credit for the orginal work done by indutny and I was originally very nervous about making 
+this python library that I made public... 
+
+Links to the original library 
+- https://llparse.org
+- https://github.com/nodejs/llparse
+
+Unlike the typescript library all 3 of llparse's libraries were combined in this version of the code for the sake of portability... 
+I ended up mentioning how I did this a while back and I also had a concept for a C parser as well but I just didn't like it and I ended up using this instead but I also learned typescript as a bonus and It was alot of fun for me. I don't plan to make this into a real pypi library yet but I also didn't want to take away from the magic of the original source code that I borrowed from...
+
+# Looking back on my dead work 2 years later
+I had this idea lay somewhat dormant for 2 years and now seeing that I wanted to write a new socks5 server parser writing it in python
+just made a little bit more sense to me, this way I don't have to stress over typescript or needing to relearn things I learned over 2 years ago. 
+I have now made this project public on pypi for anybody who wanted to dig into it and access the code
+or generate your own parsers for C.
+
+If your better at typescript. I reccommend sticking to the typescript version, no pressure. This library aims to not compete 
+with llparse but to act as an alternative for users who prefer python over typescript/node-js, simillar to puppeteer or pyppeteer. 
+Personally maybe we should make a rust crate for a rust version or at least someone will do it. 
+
+
+## Warnings
+- It should be safe enough to generate code and stress-test it but if something doesn't seem right to you, be sure to throw an issue and share a typescript version of something that works in typescript but not in python, this way something unintended by the typescript developers can be solved.
+- Some code may look unfinished or may need further internal refactoring/polishing and with the other things I want to go out and do
+such as contributions to aiohttp and it's other libraries, cyares, winloop, aiothreading, aiocallback & deprecated-params and I also have an irl Part-time Job, ideas and pull requests are welcomed without hesitation. I maintain other projects listed above to prevent myself from experiencing burnout.
+- Pytest testsuite has not been made yet. If this is a concern to you, please throw an issue on github. (Pytests and new workflows soon!)
+- Some code might be spaghetti-code (because It's been 2 years since I touched much of the code if not at all) 
+e.g. tests module should be moved away from the library into the github repo.
+- There's some research portions such as tools to help generate things for cython or tools to make mirrors of llhttp's code
+such as it's native c code (I was looking to see if it could be theoretically autogenerated). Feel free to use them but
+do it at your own risk. They maybe incompleted or not throughly stress-tested.
+
+## New Features
+- Throw me an issue if typescript llparse introduces something new that you want for me or another contributor to try and implement 
+just seeing llparse add new features is nothing but exciting to me.
+
+- If you want a feature that typescript llparse doesn't have, be sure to try making a pull request over there as well and not just here, 
+there's a good chance they will appericate you for helping over there too and your helping make llhttp better by doing so. :)
+
+
+# Why Did I Translate llparse to python?
+- I wanted to work with a langauge I was more familiar with
+- Better educate myself and others on how these great libraries like llhttp are made
+- Write faster C code that could do more than just a simple split function or a regex...
+- Make it easy for me or someone else to find a problem and solve it in typescript after testing it in python
+- Typescript takes 2 commands to run a script with node-js it while python only takes one cutting the time required tremendously...
+- The orginal project was MIT licensed.
+- I wanted to write my own C Parsering tool with llhttp styled callbacks of my own using a language I was the most comfortable with using.
+- I didn't like __Lemon Parser__ or __Yacc__ all that much and a good ide for handling them in Visual Studio Code with error checking to my knowlegde does not exist.
+- The closest thing I got to what I wanted was a project named __NMFU__ shorthand for no memory for you and even I had problems with writing things using that library...
+
+This was the Code that inspired me to try and make a new pyi writer branch for cython and if it wasn't for llhttp 
+existing as well as it's magical experience I would've never done what I did.
+
+Unlike llparse in typescript, this version has more integrated and experimental features like automatically building the api seen in llhttp and 
+I've added a few other things like the dot compiler from llparse_dot and I also made a brand new cython compiler 
+for it making easy and simple to make pxd files to port your projects to cython 
+
+
+
+## How to use
+```python
+# The good old http_parser was borrowed from llparse.org to demonstrate this for you :)
+from llparse import LLParse
+
+p = LLParse("http_parser")
+method = p.node("method")
+beforeUrl = p.node("before_url")
+urlSpan = p.span(p.code.span("on_url"))
+url = p.node("url")
+http = p.node("http")
+
+# Add custom uint8_t property to the state
+p.property("i8", "method")
+
+# Store method inside a custom property
+onMethod = p.invoke(p.code.store("method"), beforeUrl)
+
+# Invoke custom C function
+complete = p.invoke(
+    p.code.match("on_complete"),
+    {
+        #  Restart
+        0: method
+    },
+    p.error(4, "`on_complete` error"),
+)
+
+method.select(
+    {
+        "HEAD": 0,
+        "GET": 1,
+        "POST": 2,
+        "PUT": 3,
+        "DELETE": 4,
+        "OPTIONS": 5,
+        "CONNECT": 6,
+        "TRACE": 7,
+        "PATCH": 8,
+    },
+    onMethod,
+).otherwise(p.error(5, "Expected method"))
+
+beforeUrl.match(" ", beforeUrl).otherwise(urlSpan.start(url))
+
+url.peek(" ", urlSpan.end(http)).skipTo(url)
+
+http.match(" HTTP/1.1\r\n\r\n", complete).otherwise(
+    p.error(6, "Expected HTTP/1.1 and two newlines")
+)
+
+c = p.build(method)
+print(c.c)
+open("http_parser.c", "w").write(c.c)
+open("http_parser.h", "w").write(c.header)
+```

llparse-0.1.0.dist-info/RECORD

@@ -0,0 +1,33 @@
+llparse/C_compiler.py,sha256=vwkqgkS8_6waHqxYdDBQCaIseZ1LmMckAWz-7RS4DaA,7535
+llparse/__init__.py,sha256=tOPC4p5WHuWIqzcSidAt67WBEef94QTPXvuqLSWLiKM,50
+llparse/compilator.py,sha256=8ytSUVd8b_r8qx3uptcQoOxMKPWocIGZmFOkZSNLjuY,36387
+llparse/constants.py,sha256=Aq8Q5ASm2IUv-qGwI_DqdF6aEarotinhzEWzb2IaWyA,1182
+llparse/cython_builder.py,sha256=5N2Qz9S1xqTgQJjnThWX78dLWo-MQCntZH_4YkO4G2k,11790
+llparse/debug.py,sha256=DgEsV5XJCEH-7Kn7G0LUbPIMusuUq9cDxWzK3DE6u74,592
+llparse/dot.py,sha256=VnFQCoa1MWtmZ97RYTTN2bMZt72g_Q5XSQoe_O_K5lo,6321
+llparse/enumerator.py,sha256=JqAVamWZ3ohvhnGnanDdUD3N0GriYgoyqYj5xZSQxtk,497
+llparse/frontend.py,sha256=kF1BqV7uCGIQ6rYMHd66t6TbHgmZXYbbIDZZHuNyFSI,18396
+llparse/header.py,sha256=vJgCoJcfl97O6wIUa2w-0-M0yj9V0nqwK1f5ISeGKnU,2575
+llparse/llparse.py,sha256=RA28QQYuy6rWh6i_7TTcX9WgwiOysmpahve0Kv6i8AY,4789
+llparse/settings.py,sha256=XtpeLjKNuOEsmsHqa6ZchZOi5uC0nL_YYY2cKhfLzgA,10838
+llparse/spanalloc.py,sha256=weNy9GKUfU26xswCm-eKiq3HPDWwL9NU4Qbw38HV4E4,5547
+llparse/test.py,sha256=Uz27JLVV89qDYDyPljBp17hLuOGPVvi9kUqpbE4rhiE,6280
+llparse/tire.py,sha256=V-uIKcZvNFnx3hRPeaPbA59wxWMbcCG4OmV8U71Kqp8,4737
+llparse/trie.py,sha256=8FgN13iXBOX2StXBuMQdD7B1U4cz6_JJ2qW6M_-Nepo,4585
+llparse/pybuilder/__init__.py,sha256=fQsl2Z_dRWD_xTNE7_Oox_eNrZAudc_REsdFoJ88UcU,72
+llparse/pybuilder/builder.py,sha256=3rwVurIox8JdlSo_FB-2q-mDTMEA2Mh0XIPoXJPSYAQ,8799
+llparse/pybuilder/loopchecker.py,sha256=E7_jfnNrxsg9xXhmxtg8TsSFntz1OPChMGL5c_Xno9Y,7335
+llparse/pybuilder/main_code.py,sha256=btybTCOAfE8y36Hi-f_ZBm3YMpjXK5_RSGZXt85XWDw,16361
+llparse/pybuilder/parsemap.py,sha256=3A8LQYRzYbcGYHW7QkCXHQ_4G93YMvrNhaLhqlTAflw,817
+llparse/pyfront/containers.py,sha256=_dSFLOx5KRKTdz2aIqKDUQRVRj7YgN2GHQ6z7IcCncY,897
+llparse/pyfront/front.py,sha256=GNTnxAZXcCNb_1aaylkCTlnFTRISNcAgUFE_Wv8PAM0,4545
+llparse/pyfront/implementation.py,sha256=LSDOAVHPMLcRqtPwyIPFceRAWuAA6Egbs8XSWarJsQM,2087
+llparse/pyfront/namespace.py,sha256=06SNWkt5PMS1FSkFZxSCX4ERC8-v7ihcEc6AgD1QoGM,45
+llparse/pyfront/nodes.py,sha256=liyfByTM0dNvN2QjPjAcYESlCHVzKwgbpm8mcZ4OGAg,6099
+llparse/pyfront/peephole.py,sha256=DzcI9UGIk0KT_HW2nbDxia_9UY1Rd8a7cYdPXLUI7So,1314
+llparse/pyfront/transform.py,sha256=t50b3ZaqZhsUdzcaLdAVVWB3TsYatO5UmGEomkjxv1o,371
+llparse-0.1.0.dist-info/licenses/LICENSE,sha256=U6b9Q5b3wm1f1k0LjgUIe-RPxM3MVYPQprLvn8nQ4tw,1064
+llparse-0.1.0.dist-info/METADATA,sha256=3uVzult3Yhqn7jrrlcri_sshkOyB3uYOIIiZoEEBvsw,6621
+llparse-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+llparse-0.1.0.dist-info/top_level.txt,sha256=eEVDRI2KTMgmLEBziV-L_2uXHjQhfg3-OI0R2FO48Ko,8
+llparse-0.1.0.dist-info/RECORD,,

llparse-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

llparse-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Vizonex
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

llparse-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+llparse