Skip to content

Instantly share code, notes, and snippets.

@c6401

c6401/in_progress_omnishema.py

Last active July 25, 2025 15:46
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save c6401/82d244b85a77cfcf5a17a595f06855ba to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save c6401/82d244b85a77cfcf5a17a595f06855ba to your computer and use it in GitHub Desktop.
Download ZIP
Raw
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 scmdict(data: "Json", name="My"):
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 jsondict(data: "Json", name="Data"):
import json, pathlib
pathlib.Path('tmp.json').write_text((json.dumps(_merge(data), indent=4)))
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(' ', '') }}]
{%- elif items|length == 0 -%}
list[]
{%- elif items|length == 3 and items[0] == '%OMNISCHEMA' -%}
{%- if items[1] == 'NotRequired' -%}
{{ render_notrequired(items[2], key) }}
{%- elif items[1] == 'Union' -%}
{{ render_union(items[2]) }}
{%- elif items[1] == 'Literal' -%}
{{ render_literal(items[2]) }}
{%- elif items[1] == 'Verbatim' -%}
{{ render_verbatim(items[2]) }}
{%- endif %}
{%- else -%}
list[{{ render(items[0]) }}]
{%- endif %}
{%- endmacro %}
{%- macro render_notrequired(item, key='') -%}
{%- if item is mapping -%}
NotRequired[{{ name }}{{ key and key[0].capitalize() + key[1:] }}]
{%- else -%}
NotRequired[{{render(item, key)}}]
{%- endif %}
{%- endmacro %}
{%- macro render_verbatim(item) -%}
{{ repr(item) }}
{%- endmacro %}
{%- macro render_literal(items) -%}
Literal[{% for item in items %}{{ render(item) }}{% if not loop.last %}, {% endif %}{% endfor %}]
{%- endmacro %}
{%- macro render_union(items) -%}
{% for item in items %}{{ render(item) }}{% if not loop.last %} | {% endif %}{% endfor %}
{%- endmacro %}
{%- macro render_string(item) -%}
str
{%- endmacro %}
{%- macro render_bool(item) -%}
bool
{%- endmacro %}
{%- macro render_number(item) -%}
int
{%- endmacro %}
{%- macro render_none(item) -%}
Any
{%- 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) }}
{%- else %}
{{ type(item) }}
{%- endif %}
{%- endmacro %}
{{ render(data, key='') }}
""").render(data=_merge(data), repr=repr, name=name)
def _group(data, keyfn):
result = {}
for item in data:
key = keyfn(item)
result.setdefault(key, []).append(item)
return result
def _merge_dicts(items):
required = set(items[0])
for item in items[1:]:
required &= set(item)
intermediate = {}
for item in items:
for k, v in item.items():
intermediate.setdefault(k, []).append(v)
return {
k: _merge(_union(v))
if k in required
else ("%OMNISCHEMA", "NotRequired", _merge(_union(v)))
for k, v in intermediate.items()
}
def verbatim(item):
return ("%OMNISCHEMA", "Verbatim", item)
def _literal(items):
if not isinstance(items, list):
("%OMNISCHEMA", "Literal", items)
return ("%OMNISCHEMA", "Literal", [verbatim(i) for i in set(items)])
def _union(items):
if len(items) == 1:
return items[0]
result = []
for item in items:
if isinstance(item, tuple) and item[1] == 'Union':
result.extend(item[2])
else:
result.append(item)
return ('%OMNISCHEMA', 'Union', items)
def _merge_similar(type, items):
match type:
case 'dict':
return _merge_dicts(items)
case 'str':
return _union(['str', _literal(items)])
case 'bool':
return _union(['bool', _literal(items)])
case 'int':
return _union(['int', _literal(items)])
case 'list':
return _union(items)
case 'NoneType':
return None
case _:
return items
def _merge_list(data):
grouped = _group(data, lambda x: type(x).__name__)
return [_merge_similar(key, values) for key, values in grouped.items()]
def _merge(data):
match data:
case dict():
return {k: _merge(v) for k, v in data.items()}
case list():
data = [_merge(i) for i in data]
return _merge_list(data)
case _:
return data
@_load
def scmpyd(data: "Json", name="My"):
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(' ', '') }}(BaseModel):
{%- 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()
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment