erebion/libervia-backend
Watch
1
0
Fork
You've already forked libervia-backend
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

frontends (tools/jid): remove old pyjamas code + type hints

Browse source
This commit is contained in:
Goffi 2023-05-15 17:19:54 +02:00
commit 216b3246e8
1 changed files with 65 additions and 95 deletions
Download patch file Download diff file Expand all files Collapse all files

154
sat_frontends/tools/jid.py
View file

@ -1,8 +1,7 @@
#!/usr/bin/env python3
# SAT: a jabber client
# Copyright (C) 2009-2021 Jérôme Poisson (goffi@goffi.org)
# Libervia XMPP
# Copyright (C) 2009-2023 Jérôme Poisson (goffi@goffi.org)
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
@ -17,92 +16,20 @@
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
# hack to use this module with pyjamas
try:
str("") # XXX: unicode doesn't exist in pyjamas
# normal version
class BaseJID(str):
def __new__(cls, jid_str):
self = str.__new__(cls, cls._normalize(jid_str))
return self
def __init__(self, jid_str):
pass
def _parse(self):
"""Find node domain and resource"""
node_end = self.find("@")
if node_end < 0:
node_end = 0
domain_end = self.find("/")
if domain_end == 0:
raise ValueError("a jid can't start with '/'")
if domain_end == -1:
domain_end = len(self)
self.node = self[:node_end] or None
self.domain = self[(node_end + 1) if node_end else 0 : domain_end]
self.resource = self[domain_end + 1 :] or None
from typing import Optional, Tuple
except (
TypeError,
AttributeError,
): # Error raised is not the same depending on pyjsbuild options
class JID(str):
"""This class helps manage JID (<local>@<domain>/<resource>)"""
# pyjamas version
class BaseJID(object):
def __init__(self, jid_str):
self.__internal_str = JID._normalize(jid_str)
def __new__(cls, jid_str: str) -> "JID":
return str.__new__(cls, cls._normalize(jid_str))
def __str__(self):
return self.__internal_str
def __getattr__(self, name):
return getattr(self.__internal_str, name)
def __eq__(self, other):
if not isinstance(other, JID):
return False
return (
self.node == other.node
and self.domain == other.domain
and self.resource == other.resource
)
def __hash__(self):
return hash("JID<{}>".format(self.__internal_str))
def find(self, *args):
return self.__internal_str.find(*args)
def _parse(self):
"""Find node domain and resource"""
node_end = self.__internal_str.find("@")
if node_end < 0:
node_end = 0
domain_end = self.__internal_str.find("/")
if domain_end == 0:
raise ValueError("a jid can't start with '/'")
if domain_end == -1:
domain_end = len(self.__internal_str)
self.node = self.__internal_str[:node_end] or None
self.domain = self.__internal_str[
(node_end + 1) if node_end else 0 : domain_end
]
self.resource = self.__internal_str[domain_end + 1 :] or None
class JID(BaseJID):
"""This class help manage JID (Node@Domaine/Resource)"""
def __init__(self, jid_str):
super(JID, self).__init__(jid_str)
self._parse()
def __init__(self, jid_str: str):
self._node, self._domain, self._resource = self._parse()
@staticmethod
def _normalize(jid_str):
def _normalize(jid_str: str) -> str:
"""Naive normalization before instantiating and parsing the JID"""
if not jid_str:
return jid_str
@ -110,25 +37,68 @@ class JID(BaseJID):
tokens[0] = tokens[0].lower() # force node and domain to lower-case
return "/".join(tokens)
def _parse(self) -> Tuple[Optional[str], str, Optional[str]]:
"""Find node, domain, and resource from JID"""
node_end = self.find("@")
if node_end < 0:
node_end = 0
domain_end = self.find("/")
if domain_end == 0:
raise ValueError("a jid can't start with '/'")
if domain_end == -1:
domain_end = len(self)
node = self[:node_end] or None
domain = self[(node_end + 1) if node_end else 0 : domain_end]
resource = self[domain_end + 1 :] or None
return node, domain, resource
@property
def bare(self):
def node(self) -> Optional[str]:
return self._node
@property
def local(self) -> Optional[str]:
return self._node
@property
def domain(self) -> str:
return self._domain
@property
def resource(self) -> Optional[str]:
return self._resource
@property
def bare(self) -> "JID":
if not self.node:
return JID(self.domain)
return JID("{}@{}".format(self.node, self.domain))
return JID(f"{self.node}@{self.domain}")
def is_valid(self):
def change_resource(self, resource: str) -> "JID":
"""Build a new JID with the same node and domain but a different resource.
@param resource: The new resource for the JID.
@return: A new JID instance with the updated resource.
"""
return JID(f"{self.bare}/{resource}")
def is_valid(self) -> bool:
"""
@return: True if the JID is XMPP compliant
"""
# TODO: implement real check, according to the RFC http://tools.ietf.org/html/rfc6122
return self.domain != ""
# Simple check for domain part
if not self.domain or self.domain.startswith(".") or self.domain.endswith("."):
return False
if ".." in self.domain:
return False
return True
def new_resource(entity, resource):
def new_resource(entity: JID, resource: str) -> JID:
"""Build a new JID from the given entity and resource.
@param entity (JID): original JID
@param resource (unicode): new resource
@param entity: original JID
@param resource: new resource
@return: a new JID instance
"""
return JID("%s/%s" % (entity.bare, resource))
return entity.change_resource(resource)