any-analysis 0.1.0__tar.gz

any_analysis-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+tests/
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+dist/

any_analysis-0.1.0/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AhAlpha
+
+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.

any_analysis-0.1.0/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: any-analysis
+Version: 0.1.0
+Summary: a backend server utility for `any-capture`, providing a simple interface for packet analysis.
+Author: AhAlpha
+License-Expression: MIT
+License-File: LICENSE.txt
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.8
+Requires-Dist: alptools
+Requires-Dist: fastapi
+Requires-Dist: uvicorn
+Description-Content-Type: text/markdown
+
+# any-analysis-py
+a backend server utility for `any-capture`, providing a simple interface for packet analysis.
+
+> This library currently supports only HTTP connections. It will be migrated to a WebSocket server in a future release.

any_analysis-0.1.0/README.md

@@ -0,0 +1,4 @@
+# any-analysis-py
+a backend server utility for `any-capture`, providing a simple interface for packet analysis.
+
+> This library currently supports only HTTP connections. It will be migrated to a WebSocket server in a future release.

any_analysis-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "any-analysis"
+dynamic = ["version"]
+description = 'a backend server utility for `any-capture`, providing a simple interface for packet analysis.'
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+keywords = []
+authors = [{ name = "AhAlpha" }]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3.8",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Programming Language :: Python :: Implementation :: CPython",
+  "Programming Language :: Python :: Implementation :: PyPy",
+]
+dependencies = ["alptools", "fastapi", "uvicorn"]
+
+[tool.hatch.version]
+path = "src/any_analysis/__about__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/any_analysis"]

any_analysis-0.1.0/src/any_analysis/__about__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

any_analysis-0.1.0/src/any_analysis/__init__.py

@@ -0,0 +1,4 @@
+from .__about__ import __version__
+
+from .capture import AnyCapture
+from .receiver import ReliableTcpReceiver

any_analysis-0.1.0/src/any_analysis/base/reader.py

@@ -0,0 +1,20 @@
+from atools.io_tools import IOReader
+
+
+class NetReader(IOReader):
+    @property
+    def varint(self) -> int:
+        result = 0
+        bit = 0
+        while True:
+            if self.offset == self.size:
+                if bit != 0:
+                    raise IOError(f"Unexpected end of input while reading varint, the file may be incomplete.")
+                return None
+            byte = self.u8
+            result |= (byte & 0x7F) << bit
+            bit += 7
+            if not (byte & 0x80):
+                if byte == 0 and bit != 7:
+                    raise IOError(f"Abnormal termination while reading varint, the file might not be in protobuf format.")
+                return result

any_analysis-0.1.0/src/any_analysis/capture.py

@@ -0,0 +1,52 @@
+import typing
+import uvicorn
+from contextlib import asynccontextmanager
+from fastapi import FastAPI, Request, Response
+from . import objects
+
+
+class AnyCapture:
+    def __init__(self, host="127.0.0.1", port=8900):
+        self.host = host
+        self.port = port
+        self.app = FastAPI()
+        self.http_handler = None
+        self.tcp_handler = None
+
+        @self.app.post("/http")
+        async def __on_http_event(request: Request):
+            if self.http_handler is None:
+                return Response(status_code=204)
+            http_stream = objects.HttpStream.decode(await request.body())
+            await self.http_handler(http_stream)
+            return Response(status_code=204)
+
+        @self.app.post("/tcp")
+        async def __on_tcp_event(request: Request):
+            if self.tcp_handler is None:
+                return Response(status_code=204)
+            tcp_stream = objects.TcpStream.decode(await request.body())
+            await self.tcp_handler(tcp_stream)
+            return Response(status_code=204)
+
+    def on_http_event(self):
+        def decorator(func: typing.Callable):
+            self.http_handler = func
+            return func
+
+        return decorator
+
+    def on_tcp_event(self):
+        def decorator(func: typing.Callable):
+            self.tcp_handler = func
+            return func
+
+        return decorator
+
+    def run(self):
+        @asynccontextmanager
+        async def lifespan(app: FastAPI):
+            yield
+
+        self.app.router.lifespan_context = lifespan
+        uvicorn.run(self.app, host=self.host, port=self.port, access_log=False)

any_analysis-0.1.0/src/any_analysis/objects/__init__.py

@@ -0,0 +1,2 @@
+from .http_stream import HttpStream, HttpEvent, HttpMethod
+from .tcp_stream import TcpStream, TcpEvent

any_analysis-0.1.0/src/any_analysis/objects/http_stream.py

@@ -0,0 +1,68 @@
+import zlib
+import gzip
+from enum import IntEnum
+from atools.logger import logger
+from atools.object_tools import Object
+
+from ..base.reader import NetReader
+
+
+class HttpEvent(IntEnum):
+    REQUEST = 1
+    RESPONSE = 2
+    ERROR = 3
+
+
+class HttpMethod(IntEnum):
+    GET = 1
+    POST = 2
+    PUT = 3
+    DELETE = 4
+    HEAD = 5
+    OPTIONS = 6
+    CONNECT = 7
+    PATCH = 8
+    TRACE = 9
+    OTHER = 255
+
+
+class HttpStream(Object):
+    id: int
+    event: HttpEvent
+    method: HttpMethod
+    url: str
+    status: int | None
+    headers: dict[str, str]
+    body: bytes
+
+    @staticmethod
+    def decode(buf: bytes) -> HttpStream:
+        _ = NetReader(buf)
+        http_stream = HttpStream()
+        http_stream.id = _.varint
+        http_stream.event = HttpEvent(_.u8)
+        http_stream.method = HttpMethod(_.u8)
+        http_stream.url = _.str(_.varint)
+        if http_stream.event == HttpEvent.RESPONSE:
+            http_stream.status = _.varint
+        else:
+            http_stream.status = None
+        http_stream.headers = {}
+        for _i_ in range(_.varint):
+            key = _.str(_.varint)
+            val = _.str(_.varint)
+            http_stream.headers[key] = val
+        http_stream.body = _.bytes(_.varint)
+        if _.offset != _.size:
+            logger.warning(f"package may be corrupted, {_.size - _.offset} trailing bytes.")
+        return http_stream
+
+    def auto_decompress(self):
+        content_encoding = next((value for key, value in self.headers.items() if key.lower() == "content-encoding"), "")
+        encodings = [encoding.strip().lower() for encoding in content_encoding.split(",") if encoding.strip()]
+        for encoding in reversed(encodings):
+            if encoding in {"gzip", "x-gzip"}:
+                try:
+                    self.body = gzip.decompress(self.body)
+                except (gzip.BadGzipFile, EOFError, zlib.error) as exc:
+                    raise ValueError("Invalid gzip-compressed HTTP body") from exc

any_analysis-0.1.0/src/any_analysis/objects/tcp_stream.py

@@ -0,0 +1,33 @@
+from enum import IntEnum
+from atools.object_tools import Object
+
+from ..base.reader import NetReader
+
+
+class TcpEvent(IntEnum):
+    ABOUT = 1
+    OK = 2
+    SEND = 3
+    RECEIVE = 4
+    CLIENT_CLOSE = 5
+    SERVER_CLOSE = 6
+    DISCONNECT = 7
+
+
+class TcpStream(Object):
+    id: int
+    event: TcpEvent
+    address: str
+    chunk_id: int
+    body: bytes
+
+    @staticmethod
+    def decode(buf: bytes) -> TcpStream:
+        _ = NetReader(buf)
+        tcp_stream = TcpStream()
+        tcp_stream.id = _.varint
+        tcp_stream.event = TcpEvent(_.u8)
+        tcp_stream.address = _.str(_.varint)
+        tcp_stream.chunk_id = _.varint
+        tcp_stream.body = _.bytes(_.varint)
+        return tcp_stream

any_analysis-0.1.0/src/any_analysis/receiver.py

@@ -0,0 +1,20 @@
+import asyncio
+from . import objects
+
+
+class ReliableTcpReceiver:
+    def __init__(self, chunk_id: int):
+        self.lock = asyncio.Lock()
+        self.next_chunk_id = chunk_id
+        self.pending_chunks: dict[int, objects.TcpStream] = {}
+
+    def on_tcp_packet(self, tcp_stream: objects.TcpStream):
+        ready = []
+        if tcp_stream.chunk_id < self.next_chunk_id:
+            return
+        self.pending_chunks[tcp_stream.chunk_id] = tcp_stream
+        while self.next_chunk_id in self.pending_chunks:
+            ready.append(self.pending_chunks.pop(self.next_chunk_id))
+            self.next_chunk_id += 1
+        for ordered_stream in ready:
+            yield ordered_stream

any_analysis-0.1.0/src/any_analysis/utils.py

@@ -0,0 +1,8 @@
+import re
+
+
+def url_to_name(url: str):
+    url = re.sub(r"^https?:\/\/", "", url)
+    url = re.sub(r"[\?#].*$", "", url)
+    url = re.sub(r"[./:\\*\?\"<>|]", "_", url)
+    return url