Python 3.7 新特性
# -*- encoding:utf-8 -*-
"""
@ Created by Seven on 2018/10/26
"""
from enum import Enum
from dataclasses import dataclass
from typing import Optional, Any, List, TypeVar, Type, Callable, cast
T = TypeVar("T")
EnumT = TypeVar("EnumT", bound=Enum)
def from_bool(x: Any) -> bool:
assert isinstance(x, bool)
return x
def from_str(x: Any) -> str:
assert isinstance(x, str)
return x
def from_int(x: Any) -> int:
assert isinstance(x, int) and not isinstance(x, bool)
return x
def from_none(x: Any) -> Any:
assert x is None
return x
def from_union(fs, x):
for f in fs:
try:
return f(x)
except:
pass
assert False
def to_enum(c: Type[EnumT], x: Any) -> EnumT:
assert isinstance(x, c)
return x.value
def from_list(f: Callable[[Any], T], x: Any) -> List[T]:
assert isinstance(x, list)
return [f(y) for y in x]
def to_class(c: Type[T], x: Any) -> dict:
assert isinstance(x, c)
return cast(Any, x).to_dict()
class Group(Enum):
SS = "SS"
SSR = "SSR"
class Method(Enum):
AES_256_CFB = "aes-256-cfb"
CHACHA20_IETF = "chacha20-ietf"
class Obfs(Enum):
HTTP_SIMPLE = "http_simple"
PLAIN = "plain"
TLS1_2__TICKET_AUTH = "tls1.2_ticket_auth"
class Password(Enum):
SOO9S_COM = "soo9s.com"
SOO9S_ME = "soo9s.me"
class Protocol(Enum):
AUTH_AES128_MD5 = "auth_aes128_md5"
AUTH_AES128_SHA1 = "auth_aes128_sha1"
AUTH_CHAIN_A = "auth_chain_a"
class Protocolparam(Enum):
THE_5113_CCT_IN_W = "5113:cctInW"
@dataclass
class Config:
enable: bool
password: Password
method: Method
remarks: str
server: str
obfs: Obfs
protocol: Protocol
protocolparam: Protocolparam
group: Group
server_port: int
remarks_base64: str
obfsparam: Optional[str]
@staticmethod
def from_dict(obj: Any) -> 'Config':
assert isinstance(obj, dict)
enable = from_bool(obj.get("enable"))
password = Password(obj.get("password"))
method = Method(obj.get("method"))
remarks = from_str(obj.get("remarks"))
server = from_str(obj.get("server"))
obfs = Obfs(obj.get("obfs"))
protocol = Protocol(obj.get("protocol"))
protocolparam = Protocolparam(obj.get("protocolparam"))
group = Group(obj.get("group"))
server_port = from_int(obj.get("server_port"))
remarks_base64 = from_str(obj.get("remarks_base64"))
obfsparam = from_union([from_str, from_none], obj.get("obfsparam"))
return Config(enable, password, method, remarks, server, obfs, protocol, protocolparam, group, server_port, remarks_base64, obfsparam)
def to_dict(self) -> dict:
result: dict = {}
result["enable"] = from_bool(self.enable)
result["password"] = to_enum(Password, self.password)
result["method"] = to_enum(Method, self.method)
result["remarks"] = from_str(self.remarks)
result["server"] = from_str(self.server)
result["obfs"] = to_enum(Obfs, self.obfs)
result["protocol"] = to_enum(Protocol, self.protocol)
result["protocolparam"] = to_enum(Protocolparam, self.protocolparam)
result["group"] = to_enum(Group, self.group)
result["server_port"] = from_int(self.server_port)
result["remarks_base64"] = from_str(self.remarks_base64)
result["obfsparam"] = from_union([from_str, from_none], self.obfsparam)
return result
@dataclass
class Export:
random: bool
auth_pass: None
use_online_pac: bool
ttl: int
export_global: bool
reconnect_times: int
index: int
proxy_type: int
proxy_host: None
auth_user: None
proxy_auth_pass: None
is_default: bool
pac_url: None
configs: List[Config]
proxy_port: int
random_algorithm: int
proxy_enable: bool
enabled: bool
autoban: bool
proxy_auth_user: None
share_over_lan: bool
local_port: int
@staticmethod
def from_dict(obj: Any) -> 'Export':
assert isinstance(obj, dict)
random = from_bool(obj.get("random"))
auth_pass = from_none(obj.get("authPass"))
use_online_pac = from_bool(obj.get("useOnlinePac"))
ttl = from_int(obj.get("TTL"))
export_global = from_bool(obj.get("global"))
reconnect_times = from_int(obj.get("reconnectTimes"))
index = from_int(obj.get("index"))
proxy_type = from_int(obj.get("proxyType"))
proxy_host = from_none(obj.get("proxyHost"))
auth_user = from_none(obj.get("authUser"))
proxy_auth_pass = from_none(obj.get("proxyAuthPass"))
is_default = from_bool(obj.get("isDefault"))
pac_url = from_none(obj.get("pacUrl"))
configs = from_list(Config.from_dict, obj.get("configs"))
proxy_port = from_int(obj.get("proxyPort"))
random_algorithm = from_int(obj.get("randomAlgorithm"))
proxy_enable = from_bool(obj.get("proxyEnable"))
enabled = from_bool(obj.get("enabled"))
autoban = from_bool(obj.get("autoban"))
proxy_auth_user = from_none(obj.get("proxyAuthUser"))
share_over_lan = from_bool(obj.get("shareOverLan"))
local_port = from_int(obj.get("localPort"))
return Export(random, auth_pass, use_online_pac, ttl, export_global, reconnect_times, index, proxy_type, proxy_host, auth_user, proxy_auth_pass, is_default, pac_url, configs, proxy_port, random_algorithm, proxy_enable, enabled, autoban, proxy_auth_user, share_over_lan, local_port)
def to_dict(self) -> dict:
result: dict = {}
result["random"] = from_bool(self.random)
result["authPass"] = from_none(self.auth_pass)
result["useOnlinePac"] = from_bool(self.use_online_pac)
result["TTL"] = from_int(self.ttl)
result["global"] = from_bool(self.export_global)
result["reconnectTimes"] = from_int(self.reconnect_times)
result["index"] = from_int(self.index)
result["proxyType"] = from_int(self.proxy_type)
result["proxyHost"] = from_none(self.proxy_host)
result["authUser"] = from_none(self.auth_user)
result["proxyAuthPass"] = from_none(self.proxy_auth_pass)
result["isDefault"] = from_bool(self.is_default)
result["pacUrl"] = from_none(self.pac_url)
result["configs"] = from_list(lambda x: to_class(Config, x), self.configs)
result["proxyPort"] = from_int(self.proxy_port)
result["randomAlgorithm"] = from_int(self.random_algorithm)
result["proxyEnable"] = from_bool(self.proxy_enable)
result["enabled"] = from_bool(self.enabled)
result["autoban"] = from_bool(self.autoban)
result["proxyAuthUser"] = from_none(self.proxy_auth_user)
result["shareOverLan"] = from_bool(self.share_over_lan)
result["localPort"] = from_int(self.local_port)
return result
def export_from_dict(s: Any) -> Export:
return Export.from_dict(s)
def export_to_dict(x: Export) -> Any:
return to_class(Export, x)Tags: None