feat(server): working

Signed-off-by: John Andersen <johnandersen777@protonmail.com>

Author: johnandersen777

.github/workflows/release.yml

@@ -0,0 +1,34 @@
+name: Release
+
+on:
+  push:
+    branches:
+    - "main"
+    - "v*"
+
+jobs:
+  pypi-publish:
+    name: upload release to PyPI
+    runs-on: ubuntu-latest
+    # Specifying a GitHub environment is optional, but strongly encouraged
+    environment: pypi
+    permissions:
+      # IMPORTANT: this permission is mandatory for trusted publishing
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v4
+        with:
+          python-version: "3.x"
+
+      - name: deps
+        run: python -m pip install -U build
+
+      - name: build
+        run: python -m build
+
+      - name: Publish package distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          verify-metadata: false

.python-version

@@ -0,0 +1 @@
+3.12

LICENSE

@@ -0,0 +1,23 @@
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+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 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.
+
+For more information, please refer to <http://unlicense.org/>

README.md

@@ -0,0 +1,18 @@
+# ATProto based pastebin
+
+Paste and retrive
+
+```bash
+curl -sf http://localhost:8000/$(curl -X POST --data-binary @src/atprotobin/cli.py -H "Content-Type: text/plain" http://localhost:8000/ | tee /dev/stderr | jq -r .id)
+```
+
+Start server
+
+```bash
+ATPROTO_BASE_URL=https://atproto.chadig.com ATPROTO_HANDLE=publicdomainrelay.atproto.chadig.com ATPROTO_PASSWORD=$(python -m keyring get publicdomainrelay@protonmail.com password.publicdomainrelay.atproto.chadig.com) python -m atprotobin
+```
+
+- References
+  - https://bsky.app/profile/johnandersen777.bsky.social/post/3lc47yvadu22i
+
+[![asciicast](https://asciinema.org/a/693001.svg)](https://asciinema.org/a/693001)

pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "atprotobin"
+version = "0.1.0"
+description = "ATProto based pastebin"
+readme = {file = "README.md", content-type = "text/markdown"}
+authors = [
+    { name = "Public Domain", email = "publicdomainrelay@protonmail.com" }
+]
+license = {text = "Unlicense"}
+requires-python = ">=3.12"
+dependencies = [
+    "atproto>=0.0.55",
+    "uvicorn[standard]>=0.32.1",
+    "fastapi[standard]>=0.115.5",
+    "pillow>=11.0.0",
+    "python-magic>=0.4.27",
+    "python-multipart>=0.0.19",
+]
+
+[project.urls]
+Repository = "https://github.com/publicdomainrelay/atprotobin.git"
+Issues = "https://github.com/publicdomainrelay/atprotobin/issues"
+
+[project.scripts]
+atprotobin = "atprotobin.cli:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

src/atprotobin/__init__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

src/atprotobin/__main__.py

@@ -0,0 +1,16 @@
+import os
+import asyncio
+
+import uvicorn
+
+async def async_main():
+    config = uvicorn.Config(
+        "atprotobin.server:app",
+        port=int(os.environ.get("PORT", "8000")),
+        log_level="debug",
+    )
+    server = uvicorn.Server(config)
+    await server.serve()
+
+def main() -> None:
+    asyncio.run(async_main())

src/atprotobin/cli.py

@@ -0,0 +1,64 @@
+import os
+import hashlib
+import contextlib
+from typing import Annotated
+
+from atproto import AsyncClient, models
+from fastapi import FastAPI, File, UploadFile, Request, Response
+
+from .zip_image import encode, decode
+
+app = FastAPI()
+
+hash_alg = os.environ.get("HASH_ALG", "sha256")
+atproto_base_url = os.environ["ATPROTO_BASE_URL"]
+atproto_handle = os.environ["ATPROTO_HANDLE"]
+atproto_password= os.environ["ATPROTO_PASSWORD"]
+
+did_plcs = {}
+client = AsyncClient(
+    base_url=atproto_base_url,
+)
+
+@contextlib.asynccontextmanager
+async def lifespan(app: FastAPI):
+    profile = await client.login(
+        atproto_handle,
+        atproto_password,
+    )
+    did_plcs[atproto_handle] = profile.did
+    yield
+
+app = FastAPI(lifespan=lifespan)
+
+@app.post("/")
+async def create(request: Request):
+    file_data = await request.body()
+    hash_instance = hashlib.new(hash_alg)
+    hash_instance.update(file_data)
+    data_as_image_hash = hash_instance.hexdigest()
+    data_as_image_hash = f"{hash_alg}:{data_as_image_hash}"
+    _mimetype, data_as_image = encode(file_data)
+    post = await client.send_image(
+        text=data_as_image_hash,
+        image=data_as_image,
+        image_alt=data_as_image_hash,
+    )
+    return {
+        "id": post.uri.split("/")[-1],
+        "url": f'https://bsky.app/profile/{atproto_handle}/post/{post.uri.split("/")[-1]}',
+        "uri": post.uri,
+        "cid": post.cid,
+    }
+
+@app.get("/{post_id}")
+async def get(post_id: str):
+    post = await client.get_post(post_id)
+    blob = await client.com.atproto.sync.get_blob(
+        models.com.atproto.sync.get_blob.Params(
+            cid=post.value.embed.images[0].image.ref.link,
+            did=did_plcs[atproto_handle],
+        ),
+    )
+    mimetype, output_bytes = decode(blob)
+    return Response(content=output_bytes, media_type=mimetype)

src/atprotobin/server.py

@@ -0,0 +1,97 @@
+# cat ~/Documents/publicdomainrelay/gitatp/src/gitatp/update_profile.js | python -u src/federation_git/policy_image.py | tee policy_image.png | python -u src/federation_git/policy_image.py
+import sys
+import zipfile
+from io import BytesIO
+
+import magic
+from PIL import Image, ImageDraw, ImageFont
+
+# Create a zip archive containing the internal files
+def create_zip_of_files(file_contents, file_name: str = "manifest"):
+    zip_buffer = BytesIO()
+    mimetype = magic.from_buffer(file_contents, mime=True)
+    with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zipf:
+        zipf.writestr(mimetype, file_contents)
+    zip_buffer.seek(0)
+    return mimetype, zip_buffer.read()
+
+def create_png_with_zip(zip_data, text_content):
+    """
+    Create a PNG image that contains rendered text and append zip data
+    to create a polyglot PNG/zip file.
+
+    Args:
+        zip_data (bytes): The binary data of the zip file.
+        text_content (str): The text content to render inside the PNG.
+
+    Returns:
+        bytes: The combined PNG and zip data.
+    """
+    # Font configuration
+    font_size = 14
+    try:
+        # Attempt to use a monospaced font
+        font = ImageFont.truetype("DejaVuSansMono.ttf", font_size)
+    except IOError:
+        # Fallback to default font
+        font = ImageFont.load_default()
+
+    # Calculate the size of the rendered text
+    lines = text_content.split('\n')
+    max_line_width = max(font.getbbox(line)[2] for line in lines)  # Use getbbox()[2] for width
+    line_height = font.getbbox("A")[3]  # Use getbbox()[3] for height
+    total_height = line_height * len(lines)
+
+    # Create an image with a white background
+    img = Image.new('RGB', (max_line_width + 20, total_height + 20), color='white')
+    draw = ImageDraw.Draw(img)
+
+    # Draw the text onto the image
+    y_text = 10
+    for line in lines:
+        draw.text((10, y_text), line, font=font, fill='black')
+        y_text += line_height
+
+    # Save the image to a BytesIO object
+    img_buffer = BytesIO()
+    img.save(img_buffer, format='PNG')
+    img_data = img_buffer.getvalue()
+    img_buffer.close()
+
+    # Combine the PNG image data and the zip data
+    png_zip_data = img_data + zip_data
+
+    return png_zip_data
+
+def encode(input_data):
+    text_content = input_data.decode()
+
+    # Create zip archive of internal files
+    mimetype, zip_data = create_zip_of_files(text_content)
+
+    # Create PNG with embedded zip and rendered text
+    png_zip_data = create_png_with_zip(zip_data, text_content)
+
+    # Write out image
+    return mimetype, png_zip_data
+
+def decode(data):
+    # Attempt to open the data as a zip file
+    with zipfile.ZipFile(BytesIO(data)) as zipf:
+        # Iterate through the files in the zip archive
+        for file_info in zipf.infolist():
+            with zipf.open(file_info) as file:
+                # Output the contents of each file to stdout
+                return file_info.orig_filename, file.read()
+
+def main():
+    input_data = sys.stdin.buffer.read()
+    if input_data.startswith(b"\x89PNG"):
+        mimetype, output_bytes = decode(input_data)
+    else:
+        mimetype, output_bytes = encode(input_data)
+    print(f"{mimetype}", file=sys.stderr)
+    sys.stdout.buffer.write(output_bytes)
+
+if __name__ == "__main__":
+    main()