egarette/rougail-web
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

xfirst commit

Browse source
This commit is contained in:
egarette@silique.fr 2024-11-07 07:55:46 +01:00
commit 9b71486a94
3 changed files with 480 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

37
index.html Normal file
View file

@ -0,0 +1,37 @@
<!doctype html>
<html>
<head>
<!-- Recommended meta tags -->
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width,initial-scale=1.0">
<!-- PyScript CSS -->
<link rel="stylesheet" href="https://pyscript.net/releases/2024.1.1/core.css">
<!-- This script tag bootstraps PyScript -->
<script type="module" src="https://pyscript.net/releases/2024.1.1/core.js"></script>
<!-- for splashscreen -->
<style>
#loading { outline: none; border: none; background: transparent }
</style>
<script type="module">
const loading = document.getElementById('loading');
addEventListener('py:ready', () => loading.close());
loading.showModal();
</script>
<title>PyScript Hello World</title>
</head>
<body>
<dialog id="loading">
<h1>Loading...</h1>
</dialog>
<div id="result"/>
<section class="pyscript">
<script type="py" src="./main.py" config="./pyscript.toml"></script>
</section>
</body>
</html>

440
main.py Normal file
View file

@ -0,0 +1,440 @@
from pyscript import display
from pyweb import pydom
#from pyscript.web import page
from pyscript import window, document, HTML
from pyodide.ffi import create_proxy
from tiramisu import *
from tiramisu.setting import ALLOWED_LEADER_PROPERTIES
# ROUGAIL
from typing import Any
try:
from tiramisu5 import DynOptionDescription, calc_value
except ModuleNotFoundError:
from tiramisu import DynOptionDescription, calc_value
from importlib.machinery import SourceFileLoader as _SourceFileLoader
from importlib.util import (
spec_from_loader as _spec_from_loader,
module_from_spec as _module_from_spec,
)
from jinja2 import StrictUndefined, DictLoader
from jinja2.sandbox import SandboxedEnvironment
from tiramisu import function_waiting_for_error
from tiramisu.error import ValueWarning, ConfigError, PropertiesOptionError
from unicodedata import normalize, combining
def normalize_family(family_name: str) -> str:
"""replace space, accent, uppercase, ... by valid character"""
if not family_name:
return
family_name = family_name.lower()
family_name = family_name.replace("-", "_").replace(" ", "_").replace(".", "_")
nfkd_form = normalize("NFKD", family_name)
family_name = "".join([c for c in nfkd_form if not combining(c)])
return family_name.lower()
def display_xmlfiles(xmlfiles: list) -> str:
"""The function format xmlfiles informations to generate errors"""
if len(xmlfiles) == 1:
return '"' + xmlfiles[0] + '"'
return '"' + '", "'.join(xmlfiles[:-1]) + '"' + " and " + '"' + xmlfiles[-1] + '"'
def convert_boolean(value: str) -> bool:
"""Boolean coercion. The Rougail XML may contain srings like `True` or `False`"""
if isinstance(value, bool):
return value
value = value.lower()
if value == "true":
return True
elif value == "false":
return False
elif value in ["", None]:
return None
raise Exception(f'unknown boolean value "{value}"')
CONVERT_OPTION = {
"string": dict(opttype="StrOption", example="example"),
"number": dict(opttype="IntOption", func=int, example=42),
"float": dict(opttype="FloatOption", func=float, example=1.42),
"boolean": dict(opttype="BoolOption", func=convert_boolean),
"secret": dict(opttype="PasswordOption", example="secrets"),
"mail": dict(opttype="EmailOption", example="user@example.net"),
"unix_filename": dict(opttype="FilenameOption", example="/tmp/myfile.txt"),
"date": dict(opttype="DateOption", example="2000-01-01"),
"unix_user": dict(opttype="UsernameOption", example="username"),
"ip": dict(
opttype="IPOption", initkwargs={"allow_reserved": True}, example="1.1.1.1"
),
"cidr": dict(opttype="IPOption", initkwargs={"cidr": True}, example="1.1.1.0/24"),
"netmask": dict(opttype="NetmaskOption", example="255.255.255.0"),
"network": dict(opttype="NetworkOption", example="1.1.1.0"),
"network_cidr": dict(
opttype="NetworkOption", initkwargs={"cidr": True}, example="1.1.1.0/24"
),
"broadcast": dict(opttype="BroadcastOption", example="1.1.1.255"),
"netbios": dict(
opttype="DomainnameOption",
initkwargs={"type": "netbios", "warnings_only": True},
example="example",
),
"domainname": dict(
opttype="DomainnameOption",
initkwargs={"type": "domainname", "allow_ip": False},
example="example.net",
),
"hostname": dict(
opttype="DomainnameOption",
initkwargs={"type": "hostname", "allow_ip": False},
example="example",
),
"web_address": dict(
opttype="URLOption",
initkwargs={"allow_ip": False, "allow_without_dot": True},
example="https://example.net",
),
"port": dict(
opttype="PortOption", initkwargs={"allow_private": True}, example="111"
),
"mac": dict(opttype="MACOption", example="00:00:00:00:00"),
"unix_permissions": dict(
opttype="PermissionsOption",
initkwargs={"warnings_only": True},
func=int,
example="644",
),
"choice": dict(opttype="ChoiceOption", example="a_choice"),
"regexp": dict(opttype="RegexpOption"),
#
"symlink": dict(opttype="SymLinkOption"),
}
global func
dict_env = {}
ENV = SandboxedEnvironment(loader=DictLoader(dict_env), undefined=StrictUndefined)
func = ENV.filters
ENV.compile_templates("jinja_caches", zip=None)
class JinjaError:
__slot__ = ("_err",)
def __init__(self, err):
self._err = err
def __str__(self):
raise self._err from self._err
def __repr__(self):
raise self._err from self._err
def __eq__(self, *args, **kwargs):
raise self._err from self._err
def __ge__(self, *args, **kwargs):
raise self._err from self._err
def __gt__(self, *args, **kwargs):
raise self._err from self._err
def __le__(self, *args, **kwargs):
raise self._err from self._err
def __lt__(self, *args, **kwargs):
raise self._err from self._err
def __ne__(self, *args, **kwargs):
raise self._err from self._err
def test_propertyerror(value: Any) -> bool:
return isinstance(value, JinjaError)
ENV.tests["propertyerror"] = test_propertyerror
def load_functions(path):
global _SourceFileLoader, _spec_from_loader, _module_from_spec, func
loader = _SourceFileLoader("func", path)
spec = _spec_from_loader(loader.name, loader)
func_ = _module_from_spec(spec)
loader.exec_module(func_)
for function in dir(func_):
if function.startswith("_"):
continue
func[function] = getattr(func_, function)
def rougail_calc_value(*args, __default_value=None, **kwargs):
values = calc_value(*args, **kwargs)
if __default_value is not None and values in [None, []]:
return __default_value
return values
@function_waiting_for_error
def jinja_to_function(
__internal_variable,
__internal_attribute,
__internal_jinja,
__internal_type,
__internal_multi,
__internal_files,
__default_value=None,
**kwargs,
):
global ENV, CONVERT_OPTION
kw = {}
for key, value in kwargs.items():
if isinstance(value, PropertiesOptionError):
value = JinjaError(value)
if "." in key:
c_kw = kw
path, var = key.rsplit(".", 1)
for subkey in path.split("."):
c_kw = c_kw.setdefault(subkey, {})
c_kw[var] = value
else:
if key in kw:
raise ConfigError(
f'internal error, multi key for "{key}" in jinja_to_function'
)
kw[key] = value
try:
values = ENV.get_template(__internal_jinja).render(kw, **func).strip()
except Exception as err:
raise ConfigError(
f'cannot calculating "{__internal_attribute}" attribute for variable "{__internal_variable}" in {display_xmlfiles(__internal_files)}: {err}'
) from err
convert = CONVERT_OPTION[__internal_type].get("func", str)
if __internal_multi:
values = [convert(val) for val in values.split("\n") if val != ""]
if not values and __default_value is not None:
return __default_value
return values
try:
values = convert(values)
except Exception as err:
raise ConfigError(
f'cannot converting "{__internal_attribute}" attribute for variable "{__internal_variable}" in {display_xmlfiles(__internal_files)}: {err}'
) from err
values = values if values != "" and values != "None" else None
if values is None and __default_value is not None:
return __default_value
return values
def variable_to_property(prop, value, when, inverse):
if isinstance(value, PropertiesOptionError):
raise value from value
if inverse:
is_match = value != when
else:
is_match = value == when
return prop if is_match else None
@function_waiting_for_error
def jinja_to_property(prop, when, inverse, **kwargs):
value = func["jinja_to_function"](**kwargs)
return func["variable_to_property"](prop, value is not None, when, inverse)
@function_waiting_for_error
def jinja_to_property_help(prop, **kwargs):
value = func["jinja_to_function"](**kwargs)
return (prop, f'"{prop}" ({value})')
@function_waiting_for_error
def valid_with_jinja(warnings_only=False, **kwargs):
global ValueWarning
value = func["jinja_to_function"](**kwargs)
if value:
if warnings_only:
raise ValueWarning(value)
else:
raise ValueError(value)
func["calc_value"] = rougail_calc_value
func["jinja_to_function"] = jinja_to_function
func["jinja_to_property"] = jinja_to_property
func["jinja_to_property_help"] = jinja_to_property_help
func["variable_to_property"] = variable_to_property
func["valid_with_jinja"] = valid_with_jinja
class ConvertDynOptionDescription(DynOptionDescription):
"""Identifier could be an integer, we should convert it in str
Identifier could also contain invalid character, so we should "normalize" it
"""
def convert_identifier_to_path(self, identifier):
if identifier is None:
return identifier
if not isinstance(identifier, str):
identifier = str(identifier)
return normalize_family(identifier)
def impl_getname(
self,
identifier=None,
) -> str:
"""get name"""
name = super().impl_getname(None)
if identifier is None:
return name
path_identifier = self.convert_identifier_to_path(identifier)
if "{{ identifier }}" in name:
return name.replace("{{ identifier }}", path_identifier)
return name + path_identifier
def impl_get_display_name(
self,
subconfig,
with_quote: bool = False,
) -> str:
display = super().impl_get_display_name(subconfig, with_quote=with_quote)
if "{{ identifier }}" in display:
return display.replace(
"{{ identifier }}",
self.convert_identifier_to_path(self.get_identifiers(subconfig)[-1]),
)
return display
################################################################
from re import compile as re_compile
try:
groups.namespace
except:
groups.addgroup('namespace')
ALLOWED_LEADER_PROPERTIES.add("basic")
ALLOWED_LEADER_PROPERTIES.add("standard")
ALLOWED_LEADER_PROPERTIES.add("advanced")
class Regexp_option_24(RegexpOption):
__slots__ = tuple()
_type = 'value'
Regexp_option_24._regexp = re_compile(r"^#(?:[0-9a-f]{3}){1,2}$")
dict_env['frozen_firefox.manual.{{ identifier }}_proxy.address'] = "{% if my_identifier == 'HTTPS' and _.use_for_https %}\nHTTPS is same has HTTP\n{% endif %}\n"
dict_env['frozen_firefox.manual.{{ identifier }}_proxy.port'] = "{% if my_identifier == 'HTTPS' and _.use_for_https %}\nHTTPS is same has HTTP\n{% endif %}\n"
dict_env['frozen_firefox.manual.{{ identifier }}_proxy.version'] = "{% if my_identifier == 'HTTPS' and _.use_for_https %}\nHTTPS is same has HTTP\n{% endif %}\n"
dict_env['hidden_firefox.manual.{{ identifier }}_proxy'] = "{% if my_identifier == 'HTTPS' and _.use_for_https %}\nHTTPS is same has HTTP\n{% endif %}\n"
dict_env['disabled_firefox.proxy_dns_socks5'] = "{% if _.manual.socks_proxy.version is propertyerror %}\nthe proxy mode is not manual\n{% elif _.manual.socks_proxy.version == 'v4' %}\nsocks version is v4\n{% endif %}\n"
dict_env['validators_firefox.dns_over_https.custom_dns_url'] = "{% if dns_over_https.custom_dns_url.startswith('http://') %}\nonly https is allowed\n{% endif %}\n"
dict_env['disabled_firefox.dns_over_https.custom_dns_url'] = "{% if _.provider is propertyerror or _.provider != 'Custom' %}\nprovider is not custom\n{% endif %}\n"
dict_env['default_foxyproxy.proxies.color'] = "#\n{%- for i in range(6) -%}\n{{- '0123456789abcdef' | random -}}\n{%- endfor -%}\n"
dict_env['default_foxyproxy.proxies.address'] = "{% if firefox.manual.http_proxy.address is not propertyerror %}\n{{ firefox.manual.http_proxy.address }}\n{% endif %}\n"
dict_env['disabled_foxyproxy.proxies.address'] = "{% if _.type not in ['HTTP', 'HTTPS/SSL', 'SOCKS4', 'SOCKS5'] %}\ndisabled\n{% endif %}\n"
dict_env['default_foxyproxy.proxies.port'] = "{% if firefox.manual.http_proxy.port is not propertyerror %}\n{{ firefox.manual.http_proxy.port }}\n{% endif %}\n"
dict_env['disabled_foxyproxy.proxies.port'] = "{% if _.type not in ['HTTP', 'HTTPS/SSL', 'SOCKS4', 'SOCKS5'] %}\ndisabled\n{% endif %}\n"
dict_env['disabled_foxyproxy.proxies.username'] = "{% if _.type not in ['HTTP', 'HTTPS/SSL', 'SOCKS4', 'SOCKS5'] %}\ndisabled\n{% endif %}\n"
dict_env['hidden_foxyproxy.proxies.password'] = "{% if not _.username %}\nno username defined\n{% endif %}\n"
dict_env['disabled_foxyproxy.proxies.password'] = "{% if _.type not in ['HTTP', 'HTTPS/SSL', 'SOCKS4', 'SOCKS5'] %}\ndisabled\n{% endif %}\n"
dict_env['frozen_foxyproxy.proxies.password'] = "{% if not _.username %}\nno username defined\n{% endif %}\n"
dict_env['default_foxyproxy.proxies.url'] = "{% if firefox.auto is not propertyerror %}\n{{ firefox.auto }}\n{% endif %}\n"
dict_env['disabled_foxyproxy.proxies.url'] = "{% if _.type not in ['PAC URL', 'WPAD'] %}\nproxy does not need url\n{% endif %}\n"
option_2 = ChoiceOption(name="proxy_mode", doc="Configure Proxy Access to the Internet", values=("No proxy", "Auto-detect proxy settings for this network", "Use system proxy settings", "Manual proxy configuration", "Automatic proxy configuration URL"), default="No proxy", properties=frozenset({"mandatory", "standard"}), informations={'type': 'choice', 'dictionaries': ['firefox/00-proxy.yml']})
option_5 = DomainnameOption(name="address", doc="HTTP address", type="domainname", allow_ip=True, properties=frozenset({"basic", "mandatory"}), informations={'type': 'domainname', 'dictionaries': ['firefox/10-manual.yml']})
option_6 = PortOption(name="port", doc="HTTP Port", default="8080", allow_private=True, properties=frozenset({"mandatory", "standard"}), informations={'type': 'port', 'dictionaries': ['firefox/10-manual.yml']})
optiondescription_4 = OptionDescription(name="http_proxy", doc="HTTP Proxy", children=[option_5, option_6], properties=frozenset({"basic"}), informations={'dictionaries': ['firefox/10-manual.yml']})
option_7 = BoolOption(name="use_for_https", doc="Also use this proxy for HTTPS", default=True, properties=frozenset({"mandatory", "standard"}), informations={'type': 'boolean', 'dictionaries': ['firefox/20-manual.yml']})
option_9 = DomainnameOption(name="address", doc="{{ identifier }} address", default=Calculation(func['calc_value'], Params((ParamOption(option_5)))), type="domainname", allow_ip=True, properties=frozenset({"force_default_on_freeze", "mandatory", "standard", Calculation(func['jinja_to_property'], Params((ParamValue("frozen")), kwargs={'__internal_jinja': ParamValue("frozen_firefox.manual.{{ identifier }}_proxy.address"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['firefox/20-manual.yml']), '__internal_attribute': ParamValue("frozen"), '__internal_variable': ParamValue("firefox.manual.{{ identifier }}_proxy.address"), 'my_identifier': ParamIdentifier(), 'when': ParamValue(True), 'inverse': ParamValue(False), '_.use_for_https': ParamOption(option_7, notraisepropertyerror=True)}), help_function=func['jinja_to_property_help'])}), informations={'type': 'domainname', 'default_calculation_type': 'variable', 'default_calculation': 'firefox.manual.http_proxy.address', 'dictionaries': ['firefox/20-manual.yml']})
option_10 = PortOption(name="port", doc="{{ identifier }} port", default=Calculation(func['calc_value'], Params((ParamOption(option_6)))), allow_private=True, properties=frozenset({"force_default_on_freeze", "mandatory", "standard", Calculation(func['jinja_to_property'], Params((ParamValue("frozen")), kwargs={'__internal_jinja': ParamValue("frozen_firefox.manual.{{ identifier }}_proxy.port"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['firefox/20-manual.yml']), '__internal_attribute': ParamValue("frozen"), '__internal_variable': ParamValue("firefox.manual.{{ identifier }}_proxy.port"), 'my_identifier': ParamIdentifier(), 'when': ParamValue(True), 'inverse': ParamValue(False), '_.use_for_https': ParamOption(option_7, notraisepropertyerror=True)}), help_function=func['jinja_to_property_help'])}), informations={'type': 'port', 'default_calculation_type': 'variable', 'default_calculation': 'firefox.manual.http_proxy.port', 'dictionaries': ['firefox/20-manual.yml']})
option_11 = ChoiceOption(name="version", doc="SOCKS host version used by proxy", values=("v4", "v5"), default="v5", properties=frozenset({"force_default_on_freeze", "mandatory", "standard", Calculation(func['variable_to_property'], Params((ParamValue("disabled"), ParamIdentifier()), kwargs={'when': ParamValue("HTTPS"), 'inverse': ParamValue(False)}), help_function=func['variable_to_property']), Calculation(func['jinja_to_property'], Params((ParamValue("frozen")), kwargs={'__internal_jinja': ParamValue("frozen_firefox.manual.{{ identifier }}_proxy.version"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['firefox/20-manual.yml']), '__internal_attribute': ParamValue("frozen"), '__internal_variable': ParamValue("firefox.manual.{{ identifier }}_proxy.version"), 'my_identifier': ParamIdentifier(), 'when': ParamValue(True), 'inverse': ParamValue(False), '_.use_for_https': ParamOption(option_7, notraisepropertyerror=True)}), help_function=func['jinja_to_property_help'])}), informations={'type': 'choice', 'dictionaries': ['firefox/20-manual.yml'], 'disabled_calculation_type': 'identifier', 'disabled_calculation': 'when the identifier is "HTTPS"'})
optiondescription_8 = ConvertDynOptionDescription(name="{{ identifier }}_proxy", doc="{{ identifier }} Proxy", identifiers=["HTTPS", "SOCKS"], children=[option_9, option_10, option_11], properties=frozenset({"standard", Calculation(func['jinja_to_property'], Params((ParamValue("hidden")), kwargs={'__internal_jinja': ParamValue("hidden_firefox.manual.{{ identifier }}_proxy"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['firefox/20-manual.yml']), '__internal_attribute': ParamValue("hidden"), '__internal_variable': ParamValue("firefox.manual.{{ identifier }}_proxy"), 'my_identifier': ParamIdentifier(), 'when': ParamValue(True), 'inverse': ParamValue(False), '_.use_for_https': ParamOption(option_7, notraisepropertyerror=True)}), help_function=func['jinja_to_property_help'])}), informations={'dictionaries': ['firefox/20-manual.yml'], 'hidden_calculation_type': 'jinja', 'hidden_calculation': 'in HTTPS case if "manual.use_for_https" is set to True\n'})
optiondescription_3 = OptionDescription(name="manual", doc="Manual proxy configuration", children=[optiondescription_4, option_7, optiondescription_8], properties=frozenset({"basic", Calculation(func['variable_to_property'], Params((ParamValue("disabled"), ParamOption(option_2)), kwargs={'when': ParamValue("Manual proxy configuration"), 'inverse': ParamValue(True)}), help_function=func['variable_to_property'])}), informations={'dictionaries': ['firefox/10-manual.yml', 'firefox/20-manual.yml'], 'disabled_calculation_type': 'variable', 'disabled_calculation': 'when the variable "firefox.proxy_mode" hasn\'t the value "Manual proxy configuration"'})
option_12 = URLOption(name="auto", doc="Automatic proxy configuration URL", allow_ip=False, allow_without_dot=True, properties=frozenset({"basic", "mandatory", Calculation(func['variable_to_property'], Params((ParamValue("disabled"), ParamOption(option_2)), kwargs={'when': ParamValue("Automatic proxy configuration URL"), 'inverse': ParamValue(True)}), help_function=func['variable_to_property'])}), informations={'type': 'web_address', 'dictionaries': ['firefox/30-auto.yml'], 'disabled_calculation_type': 'variable', 'disabled_calculation': 'when the variable "firefox.proxy_mode" hasn\'t the value "Automatic proxy configuration URL"'})
option_13 = DomainnameOption(name="no_proxy", doc="Address for which proxy will be desactivated", multi=True, type="domainname", allow_ip=True, allow_cidr_network=True, allow_without_dot=True, allow_startswith_dot=True, properties=frozenset({"standard", Calculation(func['variable_to_property'], Params((ParamValue("disabled"), ParamOption(option_2)), kwargs={'when': ParamValue("No proxy"), 'inverse': ParamValue(False)}), help_function=func['variable_to_property'])}), informations={'type': 'domainname', 'examples': ('.mozilla.org', '.net.nz', '192.168.1.0/24'), 'help': 'Connections to localhost, 127.0.0.1/8 and ::1 are never proxied', 'dictionaries': ['firefox/40-no_proxy.yml'], 'disabled_calculation_type': 'variable', 'disabled_calculation': 'when the variable "firefox.proxy_mode" has the value "No proxy"'})
option_14 = BoolOption(name="prompt_authentication", doc="Prompt for authentication if password is saved", default=True, properties=frozenset({"mandatory", "standard", Calculation(func['variable_to_property'], Params((ParamValue("disabled"), ParamOption(option_2)), kwargs={'when': ParamValue("No proxy"), 'inverse': ParamValue(False)}), help_function=func['variable_to_property'])}), informations={'type': 'boolean', 'dictionaries': ['firefox/50-prompt_authentication.yml'], 'disabled_calculation_type': 'variable', 'disabled_calculation': 'when the variable "firefox.proxy_mode" has the value "No proxy"'})
option_15 = BoolOption(name="proxy_dns_socks5", doc="Use proxy DNS when using SOCKS v5", default=False, properties=frozenset({"advanced", "mandatory", Calculation(func['jinja_to_property'], Params((ParamValue("disabled")), kwargs={'__internal_jinja': ParamValue("disabled_firefox.proxy_dns_socks5"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['firefox/55-proxy_dns_socks5.yml']), '__internal_attribute': ParamValue("disabled"), '__internal_variable': ParamValue("firefox.proxy_dns_socks5"), 'when': ParamValue(True), 'inverse': ParamValue(False), '_.manual.socks_proxy.version': ParamDynOption(option_11, ["socks"], notraisepropertyerror=True)}), help_function=func['jinja_to_property_help'])}), informations={'type': 'boolean', 'dictionaries': ['firefox/55-proxy_dns_socks5.yml'], 'disabled_calculation_type': 'jinja', 'disabled_calculation': 'if "firefox.proxy_mode" is not "Manual proxy configuration"\nor "firefox.manual.socks_proxy.version" is "v4"\n'})
option_17 = BoolOption(name="enable_dns_over_https", doc="Enable DNS over HTTPS", default=False, properties=frozenset({"mandatory", "standard"}), informations={'type': 'boolean', 'dictionaries': ['firefox/60-dns_over_https.yml']})
option_18 = ChoiceOption(name="provider", doc="Use Provider", values=("Cloudflare", "NextDNS", "Custom"), default="Cloudflare", properties=frozenset({"mandatory", "standard", Calculation(func['variable_to_property'], Params((ParamValue("disabled"), ParamOption(option_17)), kwargs={'when': ParamValue(False), 'inverse': ParamValue(False)}), help_function=func['variable_to_property'])}), informations={'type': 'choice', 'dictionaries': ['firefox/60-dns_over_https.yml'], 'disabled_calculation_type': 'variable', 'disabled_calculation': 'when the variable "firefox.dns_over_https.enable_dns_over_https" has the value "False"'})
option_19 = URLOption(name="custom_dns_url", doc="Custom DNS URL", validators=[Calculation(func['valid_with_jinja'], Params((), kwargs={'__internal_jinja': ParamValue("validators_firefox.dns_over_https.custom_dns_url"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['firefox/60-dns_over_https.yml']), '__internal_attribute': ParamValue("validators"), '__internal_variable': ParamValue("firefox.dns_over_https.custom_dns_url")}))], allow_ip=False, allow_without_dot=True, properties=frozenset({"basic", "mandatory", Calculation(func['jinja_to_property'], Params((ParamValue("disabled")), kwargs={'__internal_jinja': ParamValue("disabled_firefox.dns_over_https.custom_dns_url"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['firefox/60-dns_over_https.yml']), '__internal_attribute': ParamValue("disabled"), '__internal_variable': ParamValue("firefox.dns_over_https.custom_dns_url"), 'when': ParamValue(True), 'inverse': ParamValue(False), '_.provider': ParamOption(option_18, notraisepropertyerror=True)}), help_function=func['jinja_to_property_help'])}), informations={'type': 'web_address', 'validators_calculation_type_0': 'jinja', 'validators_calculation_0': "must starts with 'https://' only", 'dictionaries': ['firefox/60-dns_over_https.yml'], 'disabled_calculation_type': 'jinja', 'disabled_calculation': 'if "dns_over_https.provider" is not "Custom"'})
optiondescription_16 = OptionDescription(name="dns_over_https", doc="DNS over HTTPS", children=[option_17, option_18, option_19], properties=frozenset({"basic"}), informations={'dictionaries': ['firefox/60-dns_over_https.yml']})
optiondescription_1 = OptionDescription(name="firefox", doc="firefox", group_type=groups.namespace, children=[option_2, optiondescription_3, option_12, option_13, option_14, option_15, optiondescription_16], properties=frozenset({"basic"}), informations={'dictionaries': ['']})
option_22 = StrOption(name="title", doc="Title or Description", multi=True, default=["example"], properties=frozenset({"standard"}), informations={'type': 'string', 'fake_default': True, 'dictionaries': ['foxyproxy/00-foxyproxy.yml']})
option_23 = ChoiceOption(name="type", doc="Proxy Type", values=("HTTP", "HTTPS/SSL", "SOCKS4", "SOCKS5", "PAC URL", "WPAD", "System (use system settings)", "Direct (no proxy)"), multi=True, default_multi="Direct (no proxy)", properties=frozenset({"mandatory", "standard"}), informations={'type': 'choice', 'dictionaries': ['foxyproxy/00-foxyproxy.yml']})
option_24 = Regexp_option_24(name="color", doc="Color", multi=True, default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_foxyproxy.proxies.color"), '__internal_type': ParamValue("regexp"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['foxyproxy/00-foxyproxy.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("foxyproxy.proxies.color")})), properties=frozenset({"basic", "force_store_value", "mandatory"}), informations={'type': 'regexp', 'default_calculation_type': 'jinja', 'default_calculation': 'random color value', 'dictionaries': ['foxyproxy/00-foxyproxy.yml']})
option_25 = DomainnameOption(name="address", doc="IP address, DNS name, server name", multi=True, default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_foxyproxy.proxies.address"), '__internal_type': ParamValue("domainname"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['foxyproxy/00-foxyproxy.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("foxyproxy.proxies.address"), 'firefox.manual.http_proxy.address': ParamOption(option_5, notraisepropertyerror=True)})), type="domainname", allow_ip=True, allow_without_dot=True, properties=frozenset({"mandatory", "standard", Calculation(func['jinja_to_property'], Params((ParamValue("disabled")), kwargs={'__internal_jinja': ParamValue("disabled_foxyproxy.proxies.address"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['foxyproxy/00-foxyproxy.yml']), '__internal_attribute': ParamValue("disabled"), '__internal_variable': ParamValue("foxyproxy.proxies.address"), 'when': ParamValue(True), 'inverse': ParamValue(False), '_.type': ParamOption(option_23, notraisepropertyerror=True)}), help_function=func['jinja_to_property_help'])}), informations={'type': 'domainname', 'default_calculation_type': 'jinja', 'default_calculation': 'copy HTTP address if proxy is not "Manual"', 'dictionaries': ['foxyproxy/00-foxyproxy.yml'], 'disabled_calculation_type': 'jinja', 'disabled_calculation': 'if type not in:\n- HTTP\n- HTTPS/SSL\n- SOCKS4\n- SOCKS5\n'})
option_26 = PortOption(name="port", doc="Port", multi=True, default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_foxyproxy.proxies.port"), '__internal_type': ParamValue("port"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['foxyproxy/00-foxyproxy.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("foxyproxy.proxies.port"), 'firefox.manual.http_proxy.port': ParamOption(option_6, notraisepropertyerror=True)})), allow_private=True, properties=frozenset({"mandatory", "standard", Calculation(func['jinja_to_property'], Params((ParamValue("disabled")), kwargs={'__internal_jinja': ParamValue("disabled_foxyproxy.proxies.port"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['foxyproxy/00-foxyproxy.yml']), '__internal_attribute': ParamValue("disabled"), '__internal_variable': ParamValue("foxyproxy.proxies.port"), 'when': ParamValue(True), 'inverse': ParamValue(False), '_.type': ParamOption(option_23, notraisepropertyerror=True)}), help_function=func['jinja_to_property_help'])}), informations={'type': 'port', 'default_calculation_type': 'jinja', 'default_calculation': 'copy HTTP port if proxy is not "Manual"', 'dictionaries': ['foxyproxy/00-foxyproxy.yml'], 'disabled_calculation_type': 'jinja', 'disabled_calculation': 'if type not in:\n- HTTP\n- HTTPS/SSL\n- SOCKS4\n- SOCKS5\n'})
option_27 = UsernameOption(name="username", doc="Username", multi=True, properties=frozenset({"standard", Calculation(func['jinja_to_property'], Params((ParamValue("disabled")), kwargs={'__internal_jinja': ParamValue("disabled_foxyproxy.proxies.username"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['foxyproxy/00-foxyproxy.yml']), '__internal_attribute': ParamValue("disabled"), '__internal_variable': ParamValue("foxyproxy.proxies.username"), 'when': ParamValue(True), 'inverse': ParamValue(False), '_.type': ParamOption(option_23, notraisepropertyerror=True)}), help_function=func['jinja_to_property_help'])}), informations={'type': 'unix_user', 'dictionaries': ['foxyproxy/00-foxyproxy.yml', 'foxyproxy/10-redefine.yml'], 'disabled_calculation_type': 'jinja', 'disabled_calculation': 'if type not in:\n- HTTP\n- HTTPS/SSL\n- SOCKS4\n- SOCKS5\n'})
option_28 = PasswordOption(name="password", doc="Password", multi=True, properties=frozenset({"force_default_on_freeze", "standard", Calculation(func['jinja_to_property'], Params((ParamValue("hidden")), kwargs={'__internal_jinja': ParamValue("hidden_foxyproxy.proxies.password"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['foxyproxy/10-redefine.yml']), '__internal_attribute': ParamValue("hidden"), '__internal_variable': ParamValue("foxyproxy.proxies.password"), 'when': ParamValue(True), 'inverse': ParamValue(False), '_.username': ParamOption(option_27, notraisepropertyerror=True)}), help_function=func['jinja_to_property_help']), Calculation(func['jinja_to_property'], Params((ParamValue("disabled")), kwargs={'__internal_jinja': ParamValue("disabled_foxyproxy.proxies.password"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['foxyproxy/00-foxyproxy.yml']), '__internal_attribute': ParamValue("disabled"), '__internal_variable': ParamValue("foxyproxy.proxies.password"), 'when': ParamValue(True), 'inverse': ParamValue(False), '_.type': ParamOption(option_23, notraisepropertyerror=True)}), help_function=func['jinja_to_property_help']), Calculation(func['jinja_to_property'], Params((ParamValue("frozen")), kwargs={'__internal_jinja': ParamValue("frozen_foxyproxy.proxies.password"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['foxyproxy/10-redefine.yml']), '__internal_attribute': ParamValue("frozen"), '__internal_variable': ParamValue("foxyproxy.proxies.password"), 'when': ParamValue(True), 'inverse': ParamValue(False), '_.username': ParamOption(option_27, notraisepropertyerror=True)}), help_function=func['jinja_to_property_help'])}), informations={'type': 'secret', 'dictionaries': ['foxyproxy/00-foxyproxy.yml', 'foxyproxy/10-redefine.yml'], 'hidden_calculation_type': 'jinja', 'hidden_calculation': 'if username is not defined', 'disabled_calculation_type': 'jinja', 'disabled_calculation': 'if type not in:\n- HTTP\n- HTTPS/SSL\n- SOCKS4\n- SOCKS5\n'})
option_29 = URLOption(name="url", doc="URL", multi=True, default=Calculation(func['jinja_to_function'], Params((), kwargs={'__internal_jinja': ParamValue("default_foxyproxy.proxies.url"), '__internal_type': ParamValue("web_address"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['foxyproxy/00-foxyproxy.yml']), '__internal_attribute': ParamValue("default"), '__internal_variable': ParamValue("foxyproxy.proxies.url"), 'firefox.auto': ParamOption(option_12, notraisepropertyerror=True)})), allow_ip=False, allow_without_dot=True, properties=frozenset({"mandatory", "standard", Calculation(func['jinja_to_property'], Params((ParamValue("disabled")), kwargs={'__internal_jinja': ParamValue("disabled_foxyproxy.proxies.url"), '__internal_type': ParamValue("string"), '__internal_multi': ParamValue(False), '__internal_files': ParamValue(['foxyproxy/00-foxyproxy.yml']), '__internal_attribute': ParamValue("disabled"), '__internal_variable': ParamValue("foxyproxy.proxies.url"), 'when': ParamValue(True), 'inverse': ParamValue(False), '_.type': ParamOption(option_23, notraisepropertyerror=True)}), help_function=func['jinja_to_property_help'])}), informations={'type': 'web_address', 'default_calculation_type': 'jinja', 'default_calculation': 'copy HTTP address if proxy is "Auto"', 'dictionaries': ['foxyproxy/00-foxyproxy.yml'], 'disabled_calculation_type': 'jinja', 'disabled_calculation': 'if type is not in:\n- PAC URL\n- WPAD\n'})
optiondescription_21 = Leadership(name="proxies", doc="Proxy configuration", children=[option_22, option_23, option_24, option_25, option_26, option_27, option_28, option_29], properties=frozenset({"basic"}), informations={'dictionaries': ['foxyproxy/00-foxyproxy.yml', 'foxyproxy/10-redefine.yml']})
optiondescription_20 = OptionDescription(name="foxyproxy", doc="foxyproxy", group_type=groups.namespace, children=[optiondescription_21], properties=frozenset({"basic"}), informations={'dictionaries': ['']})
option_0 = OptionDescription(name="baseoption", doc="baseoption", children=[optiondescription_1, optiondescription_20])
cfg = Config(option_0)
cfg.property.read_write()
def _regen(*args):
print(args)
def v(parent, out, level=0):
sublevel = level + 1
for key, value in parent.items():
if key.isoptiondescription():
out.content = HTML(f'<h{sublevel}>{key.description()}</h{sublevel}>')
v(value, out, sublevel)
else:
option_type = key.information.get('type')
if option_type == 'choice':
options = []
for choice in key.value.list():
if choice == value:
selected = ' selected'
else:
selected = ''
options.append(f'<option value="{choice}"{selected}>{choice}</option>')
html = HTML(f'{key.description()}: <select id="{key.path()}">{"".join(options)}</select>')
out.content = html
# input_ = document.querySelector(f"#{key.path()}")
# print(input_)
# input_.onchange = on_change
html.onchange = regen
elif option_type == 'boolean':
if value:
checked = ' checked'
else:
checked = ''
out.content = HTML(f'{key.description()}: <input type="checkbox"{checked}/>')
else:
if value is None:
value = ''
out.content = HTML(f'{key.description()}: <input type="text" value="{value}"/>')
out = pydom["#result"][0]
out.html = ''
v(cfg.value.get(), out)
async def regen(*args):
print(args)
_regen()
#proxy = create_proxy(regen)
#document.body.addEventListener("click", proxy)
_regen()

3
pyscript.toml Normal file
View file

@ -0,0 +1,3 @@
name = "Hello World"
description = "Basic hello world example that displays text in a page with PyScript."
packages = ["tiramisu", "jinja2"]