xfirst commit
This commit is contained in:
commit
9b71486a94
3 changed files with 480 additions and 0 deletions
37
index.html
Normal file
37
index.html
Normal 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
440
main.py
Normal 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
3
pyscript.toml
Normal file
|
|
@ -0,0 +1,3 @@
|
|||
name = "Hello World"
|
||||
description = "Basic hello world example that displays text in a page with PyScript."
|
||||
packages = ["tiramisu", "jinja2"]
|
||||
Loading…
Reference in a new issue