in_progress_omnishema.py

#!/usr/bin/env -S uv run --with=pyyaml --with=jinja2 --with=fire python
#s.py
# python -mfire s.py
# type: ignore
from jinja2 import Template
from functools import wraps

def _clip():
    from tkinter import Tk
    tk = Tk()
    clip = tk.clipboard_get()
    tk.destroy()
    return clip

def _load(func):
    @wraps(func)
    def wrapper(data, *a, **kw):
        if not isinstance(data, str):
            return func(data, *a, **kw)
        if data == 'clip':
            clipboard = _clip()
            import yaml
            data = yaml.safe_load(clipboard)
        elif data.startswith('http'):
            import requests
            data = requests.get(data, verify=False).json()
        else:
            import yaml
            with open(data) as f:
                data = yaml.safe_load(f)
        return func(data)
    return wrapper

@_load
def harpy(data, method='post'):
    import json
    return Template("""\
{%- set bl={
    "sec-ch-ua-platform": 0, "sec-ch-ua": 0, "sec-ch-ua-mobile": 0, "Sec-Fetch-Site":0, "Sec-Fetch-Mode":0,
    "Connection": 0, "Accept-Language": 0, "Accept-Encoding": 0, 
    "Content-Length": 0, "Cache-Control": 0,
} -%}
# %%
import httpx
from IPython.core.display import HTML

# %%
{%- 
    for e in log.entries
    if not '.gif' in e.request.url
    if method_filter in e.request.method.lower()
%}
response = httpx.{{ e.request.method.lower() }}(
    "{{ e.request.url }}",
    headers={
        {%- for h in e.request.headers if not h.name in bl %}
        '{{ h.name }}': '{{ h.value }}',
        {%- endfor %}
    },

    {%- if e.request.queryString %}
    params={
        {%- for h in e.request.queryString %}
        '{{ h.name }}': '{{ h.value }}',
        {%- endfor %}
    },
    {%- endif %}    

    {%- if e.request.postData and e.request.postData.mimeType == 'application/x-www-form-urlencoded' and e.request.postData.params %}
    data={
        {%- for p in e.request.postData.params %}
        '{{ p.name }}': '{{ p.value }}',
        {%- endfor %}
    },
    {%- endif %}

    {%- if e.request.postData and e.request.postData.mimeType == 'application/json' %}
    json={{ json.dumps(json.loads(e.request.postData.text), indent=4) }},
    {%- endif %}

    verify=False,
    follow_redirects=True,
)
HTML(response.text)

# %%

{%- endfor %}
""").render(data, rp=repr, method_filter=method, json=json)


@_load
def swagcli(data):
    return Template("""\
import httpx

base_path = ""

{%- for p, pdata in paths.items() %}
{%- for v, vdata in pdata %}
def {{ v.operationId }}
{%- %}
{%- endfor %}
""").render(data, rp=repr)


@_load
def harswag(data):
    # Initialize OpenAPI structure
    openapi_spec = {
        "openapi": "3.0.0",
        "info": {
            "title": "Generated API",
            "version": "1.0.0"
        },
        "paths": {}
    }

    # Iterate through each entry in the HAR file
    for entry in data['log']['entries']:
        request = entry['request']
        response = entry['response']
        
        # Extract method, URL, and other details
        method = request['method'].lower()
        url = request['url']
        
        # Create path if it doesn't exist
        path = url.split('?')[0]  # Ignore query parameters for path
        openapi_spec['paths'].setdefault(path, {})
        
        # Add operation to the path
        openapi_spec['paths'][path][method] = {
            "summary": f"{method.upper()} request to {path}",
            "responses": {
                str(response['status']): {
                    "description": response['statusText'],
                    "content": {
                        "application/json": {
                            "schema": {
                                "type": "object"
                            }
                        }
                    }
                }
            }
        }

    return openapi_spec

@_load
def topytype(data: "Json", name="SubscriptionResult"):
    return Template("""\
{%- macro render_mapping(item, key='') -%}
{%- for key, value in item.items() if key %}
  {%- if value is mapping %}
    {{- render(value, key=key) }}
  {%- elif value is sequence and value and value[0] is mapping %}
    {{- render(value[0], key=key) }}
{##}
  {%- endif %}
{%- endfor %}


class {{ name }}{{ key and key.replace('_', ' ').title().replace(' ', '') }}(TypedDict):
{%- for key, value in item.items() if key %}
  {%- if value is mapping %}
    {{ key }}: {{ name }}{{ key and key.replace('_', ' ').title().replace(' ', '') }}
  {%- else %}
    {{ key }}: {{ render(value, key=key) }}
  {%- endif %}
{%- endfor %}
{%- endmacro %}


{%- macro render_sequence(items, key='') -%}
{%- if items[0] is mapping -%}
List[{{ name }}{{ key and key.replace('_', ' ').title().replace(' ', '') }}]
{%- else -%}
List[{{ render(items[0]) }}]
{%- endif %}
{%- endmacro %}


{%- macro render_string(item) -%}
str
{%- endmacro %}


{%- macro render_bool(item) -%}
bool
{%- endmacro %}


{%- macro render_number(item) -%}
int
{%- endmacro %}


{%- macro render_none(item) -%}
None
{%- endmacro %}


{%- macro render(item, key='') -%}
  {%- if item is mapping %}
    {{- render_mapping(item, key=key) }}
  {%- elif item is iterable and item is not string %}
    {{- render_sequence(item, key=key) }}
  {%- elif item is string %}
    {{- render_string(item) }}
  {%- elif item in (true, false) %}
    {{- render_bool(item) }}
  {%- elif item is number %}
    {{- render_number(item) }}
  {%- elif item is none %}
    {{- render_none(item) }}
  {%- endif %}
{%- endmacro %}

{{ render(data, key='') }}
""").render(data=data, rp=repr, name=name)
    
@_load
def id(data):
    import json
    return json.dumps(data, indent=4)

if __name__ == '__main__':
    from fire import Fire
    Fire()