libervia-backend: sat.tac comparison

comparison sat.tac @ 69:86f1f7f6d332

i18n first draft - gettext support added in SàT - first draft of french translation - added README with a HOWTO for translators

author	Goffi <goffi@goffi.org>
date	Wed, 03 Mar 2010 17:12:23 +1100
parents	9b842086d915
children	f271fff3a713

comparison

equal deleted inserted replaced

-:9b842086d915
+:86f1f7f6d332
 'client_name' : u'SàT (Salut à toi)',
 'client_version' : u'0.0.2D',   #Please add 'D' at the end for dev versions
 'local_dir' : '~/.sat'
 }
 from twisted.application import internet, service
 from twisted.internet import glib2reactor, protocol, task
 glib2reactor.install()
 from twisted.words.protocols.jabber import jid, xmlstream
 import os.path
 from tools.memory import Memory
 from tools.xml_tools import XMLTools
 from glob import glob
+import gettext
+gettext.install('sat', "i18n", unicode=True)
 try:
 from twisted.words.protocols.xmlstream import XMPPHandler
 except ImportError:
 from wokkel.subprotocols import XMPPHandler
 def _authd(self, xmlstream):
 print "SatXMPPClient"
 client.XMPPClient._authd(self, xmlstream)
 self.__connected=True
-print "********** [%s] CONNECTED **********" % self.profile
+info (_("********** [%s] CONNECTED **********") % self.profile)
 self.streamInitialized()
 self.host_app.bridge.connected(self.profile) #we send the signal to the clients
 def streamInitialized(self):
 """Called after _authd"""
-debug ("XML stream is initialized")
+debug (_("XML stream is initialized"))
 self.keep_alife = task.LoopingCall(self.xmlstream.send, " ")  #Needed to avoid disconnection (specially with openfire)
 self.keep_alife.start(180)
 self.disco = SatDiscoProtocol(self)
 self.disco.setHandlerParent(self)
 def isConnected(self):
 return self.__connected
 def connectionLost(self, connector, unused_reason):
 self.__connected=False
-print "********** [%s] DISCONNECTED **********" % self.profile
+info (_("********** [%s] DISCONNECTED **********") % self.profile)
 try:
 self.keep_alife.stop()
 except AttributeError:
-debug("No keep_alife")
+debug (_("No keep_alife"))
 self.host_app.bridge.disconnected(self.profile) #we send the signal to the clients
 class SatMessageProtocol(xmppim.MessageProtocol):
 def __init__(self, host):
 xmppim.MessageProtocol.__init__(self)
 self.host = host
 def onMessage(self, message):
-debug (u"got_message from: %s", message["from"])
+debug (_(u"got message from: %s"), message["from"])
 for e in message.elements():
 if e.name == "body":
 type = message['type'] if message.hasAttribute('type') else 'chat' #FIXME: check specs
 self.host.bridge.newMessage(message["from"], e.children[0], type, profile=self.parent.profile)
 self.host.memory.addToHistory(self.parent.jid, jid.JID(message["from"]), self.parent.jid, "chat", e.children[0])
 'from': str(item.subscriptionFrom),
 'ask': str(item.ask)
 }
 if item.name:
 item_attr['name'] = item.name
-info ("new contact in roster list: %s", item.jid.full())
+info (_("new contact in roster list: %s"), item.jid.full())
 self.host.memory.addContact(item.jid, item_attr, item.groups, self.parent.profile)
 self.host.bridge.newContact(item.jid.full(), item_attr, item.groups, self.parent.profile)
 def onRosterRemove(self, entity):
 """Called when a roster removal event is received"""
 #TODO: send a signal to frontends
-print "removing %s from roster list" % entity.full()
+print _("removing %s from roster list") % entity.full()
 self.host.memory.delContact(entity, self.parent.profile)
 class SatPresenceProtocol(xmppim.PresenceClientProtocol):
 def __init__(self, host):
 xmppim.PresenceClientProtocol.__init__(self)
 self.host = host
 def availableReceived(self, entity, show=None, statuses=None, priority=0):
-info ("presence update for [%s]", entity)
+info (_("presence update for [%s]"), entity)
 if statuses.has_key(None):   #we only want string keys
 statuses["default"] = statuses[None]
 del statuses[None]
 statuses[None] = statuses['default']
 del statuses['default']
 xmppim.PresenceClientProtocol.available(self, entity, show, statuses, priority)
 def subscribedReceived(self, entity):
-debug ("subscription approved for [%s]" % entity.userhost())
+debug (_("subscription approved for [%s]") % entity.userhost())
 self.host.memory.delWaitingSub(entity.userhost(), self.parent.profile)
 self.host.bridge.subscribe('subscribed', entity.userhost(), self.parent.profile)
 def unsubscribedReceived(self, entity):
-debug ("unsubscription confirmed for [%s]" % entity.userhost())
+debug (_("unsubscription confirmed for [%s]") % entity.userhost())
 self.host.memory.delWaitingSub(entity.userhost(), self.parent.profile)
 self.host.bridge.subscribe('unsubscribed', entity.userhost(), self.parent.profile)
 def subscribeReceived(self, entity):
-debug ("subscription request for [%s]" % entity.userhost())
+debug (_("subscription request for [%s]") % entity.userhost())
 self.host.memory.addWaitingSub('subscribe', entity.userhost(), self.parent.profile)
 self.host.bridge.subscribe('subscribe', entity.userhost(), self.parent.profile)
 def unsubscribeReceived(self, entity):
-debug ("unsubscription asked for [%s]" % entity.userhost())
+debug (_("unsubscription asked for [%s]") % entity.userhost())
 self.host.memory.addWaitingSub('unsubscribe', entity.userhost(), self.parent.profile)
 self.host.bridge.subscribe('unsubscribe', entity.userhost(), self.parent.profile)
 class SatDiscoProtocol(disco.DiscoClientProtocol):
 def __init__(self, host):
 self.host = host
 self.jabber_host = jabber_host
 self.user_login = user_login
 self.user_pass = user_pass
 self.answer_id = answer_id
-print "Registration asked for",user_login, user_pass, jabber_host
+print _("Registration asked for"),user_login, user_pass, jabber_host
 def connectionMade(self):
 print "connectionMade"
 self.xmlstream.namespace = "jabber:client"
 _pass = query.addElement('password')
 _pass.addContent(self.user_pass)
 reg = iq.send(self.jabber_host).addCallbacks(self.registrationAnswer, self.registrationFailure)
 def registrationAnswer(self, answer):
-debug ("registration answer: %s" % answer.toXml())
+debug (_("registration answer: %s") % answer.toXml())
 answer_type = "SUCCESS"
-answer_data={"message":"Registration successfull"}
+answer_data={"message":_("Registration successfull")}
 self.host.bridge.actionResult(answer_type, self.answer_id, answer_data)
 self.xmlstream.sendFooter()
 def registrationFailure(self, failure):
-info ("Registration failure: %s" % str(failure.value))
+info (_("Registration failure: %s") % str(failure.value))
 answer_type = "ERROR"
 answer_data = {}
 if failure.value.condition == 'conflict':
 answer_data['reason'] = 'conflict'
-answer_data={"message":"Username already exists, please choose an other one"}
+answer_data={"message":_("Username already exists, please choose an other one")}
 else:
 answer_data['reason'] = 'unknown'
-answer_data={"message":"Registration failed (%s)" % str(failure.value.condition)}
+answer_data={"message":_("Registration failed (%s)") % str(failure.value.condition)}
 self.host.bridge.actionResult(answer_type, self.answer_id, answer_data)
 self.xmlstream.sendFooter()
 class SAT(service.Service):
 return sat_next_id()
 def get_const(self, name):
 """Return a constant"""
 if not CONST.has_key(name):
-error('Trying to access an undefined constant')
+error(_('Trying to access an undefined constant'))
 raise Exception
 return CONST[name]
 def set_const(self, name, value):
 """Save a constant"""
 if CONST.has_key(name):
-error('Trying to redefine a constant')
+error(_('Trying to redefine a constant'))
 raise Exception
 CONST[name] = value
 def __init__(self):
 #TODO: standardize callback system
 for plug in plug_lst:
 plug_path = 'plugins.'+plug
 __import__(plug_path)
 mod = sys.modules[plug_path]
 plug_info = mod.PLUGIN_INFO
-info ("importing plugin: %s", plug_info['name'])
+info (_("importing plugin: %s"), plug_info['name'])
 self.plugins[plug_info['import_name']] = getattr(mod, plug_info['main'])(self)
 if plug_info.has_key('handler') and plug_info['handler'] == 'yes':
 self.plugins[plug_info['import_name']].is_handler = True
 else:
 self.plugins[plug_info['import_name']].is_handler = False
 """Connect to jabber server"""
 profile = self.memory.getProfileName(profile_key)
 if not profile_key:
-error ('Trying to connect a non-exsitant profile')
+error (_('Trying to connect a non-exsitant profile'))
 return
 if (self.isConnected()):
-info("already connected !")
+info(_("already connected !"))
 return
 print "connecting..."
 current = self.profiles[profile] = SatXMPPClient(self, profile,
 jid.JID(self.memory.getParamA("JabberID", "Connection", profile_key = profile_key), profile),
 self.memory.getParamA("Password", "Connection", profile_key = profile_key),
 current.versionHandler = generic.VersionHandler(self.get_const('client_name'),
 self.get_const('client_version'))
 current.versionHandler.setHandlerParent(current)
-debug ("setting plugins parents")
+debug (_("setting plugins parents"))
 for plugin in self.plugins.iteritems():
 if plugin[1].is_handler:
 plugin[1].getHandler().setHandlerParent(current)
 current.startService()
 def disconnect(self, profile_key='@DEFAULT@'):
 """disconnect from jabber server"""
 if (not self.isConnected(profile_key)):
-info("not connected !")
+info(_("not connected !"))
 return
 profile = self.memory.getProfileName(profile_key)
-info("Disconnecting...")
+info(_("Disconnecting..."))
 self.profiles[profile].stopService()
 def startService(self):
 info("Salut à toi ô mon frère !")
 self.connect()
 def stopService(self):
 self.memory.save()
 info("Salut aussi à Rantanplan")
 def run(self):
-debug("running app")
+debug(_("running app"))
 reactor.run()
 def stop(self):
-debug("stopping app")
+debug(_("stopping app"))
 reactor.stop()
 ## Misc methods ##
 def getJidNStream(self, profile_key):
 user = jid.parse(self.memory.getParamA("JabberID", "Connection"))[0]
 password = self.memory.getParamA("Password", "Connection")
 server = self.memory.getParamA("Server", "Connection")
 if not user or not password or not server:
-info ('No user or server given')
+info (_('No user or server given'))
 #TODO: a proper error message must be sent to frontend
-self.actionResult(id, "ERROR", {'message':"No user, password or server given, can't register new account."})
+self.actionResult(id, "ERROR", {'message':_("No user, password or server given, can't register new account.")})
 return
 confirm_id = sat_next_id()
 self.__private_data[confirm_id]=id
 self.askConfirmation(confirm_id, "YES/NO",
-{"message":"Are you sure to register new account [%s] to server %s ?" % (user, server)},
+{"message":_("Are you sure to register new account [%(user)s] to server %(server)s ?") % {'user':user, 'server':server}},
 self.regisConfirmCB)
 print ("===============+++++++++++ REGISTER NEW ACCOUNT++++++++++++++============")
 print "id=",id
 print "data=",data
 def regisConfirmCB(self, id, accepted, data):
 #FIXME: gof: profile not managed here !
-print "register Confirmation CB ! (%s)" % str(accepted)
+print _("register Confirmation CB ! (%s)") % str(accepted)
 action_id = self.__private_data[id]
 del self.__private_data[id]
 user = jid.parse(self.memory.getParamA("JabberID", "Connection"))[0]
 password = self.memory.getParamA("Password", "Connection")
 server = self.memory.getParamA("Server", "Connection")
 form = XMLTools.tupleList2dataForm(fields)
 query.addChild(form.toElement())
 elif action=='CANCEL':
 query.addElement('remove')
 else:
-error ("FIXME FIXME FIXME: Unmanaged action (%s) in submitForm" % action)
+error (_("FIXME FIXME FIXME: Unmanaged action (%s) in submitForm") % action)
 raise NotImplementedError
 deferred = iq.send(target)
 return (iq['id'], deferred)
 ## Client management ##
 def setParam(self, name, value, category, profile_key='@DEFAULT@'):
 """set wanted paramater and notice observers"""
-info ("setting param: %s=%s in category %s", name, value, category)
+info (_("setting param: %(name)s=%(value)s in category %(category)s") % {'name':name, 'value':value, 'category':category})
 self.memory.setParam(name, value, category, profile_key)
 def isConnected(self, profile_key='@DEFAULT@'):
 """Return connection status of profile
 @param profile_key: key_word or profile name to determine profile name
 @return True if connected
 """
 profile = self.memory.getProfileName(profile_key)
 if not profile:
-error ('asking connection status for a non-existant profile')
+error (_('asking connection status for a non-existant profile'))
 raise Exception  #TODO: raise a proper exception
 if not self.profiles.has_key(profile):
 return False
 return self.profiles[profile].isConnected()
 """
 if type=="button":
 try:
 cb_name = self.memory.getParamA(data["name"], data["category"], "callback")
 except KeyError:
-error ("Incomplete data")
+error (_("Incomplete data"))
 return ""
 id = sat_next_id()
 self.callGeneralCB(cb_name, id, data)
 return id
 else:
-error ("Unknown action type")
+error (_("Unknown action type"))
 return ""
 ## jabber methods ##
 print "sendtype=", type  #gof
 #FIXME: check validity of recipient
 profile = self.memory.getProfileName(profile_key)
 assert(profile)
 current_jid = self.profiles[profile].jid
-debug("Sending jabber message to %s...", to)
+debug(_("Sending jabber message to %s..."), to)
 message = domish.Element(('jabber:client','message'))
 message["to"] = jid.JID(to).full()
 message["from"] = current_jid.full()
 message["type"] = type
 message.addElement("body", "jabber:client", msg)
 def subscription(self, type, raw_jid, profile_key='@DEFAULT@'):
 """Called to manage subscription"""
 profile = self.memory.getProfileName(profile_key)
 assert(profile)
 to_jid = jid.JID(raw_jid)
-debug ('subsciption request [%s] for %s', type, to_jid.full())
+debug (_('subsciption request [%(type)s] for %(jid)s') % {'type':type, 'jid':to_jid.full()})
 if type=="subscribe":
 self.profiles[profile].presence.subscribe(to_jid)
 elif type=="subscribed":
 self.profiles[profile].subscribed(to_jid)
 contact = self.memory.getContact(to_jid)
 if not contact or not bool(contact['to']): #we automatically subscribe to 'to' presence
-debug('sending automatic "to" subscription request')
+debug(_('sending automatic "to" subscription request'))
 self.subscription('subscribe', to_jid.userhost())
 elif type=="unsubscribe":
 self.profiles[profile].presence.unsubscribe(to_jid)
 elif type=="unsubscribed":
 self.profiles[profile].presence.unsubscribed(to_jid)
 ## callbacks ##
 def serverDisco(self, disco):
 """xep-0030 Discovery Protocol."""
 for feature in disco.features:
-debug ("Feature found: %s",feature)
+debug (_("Feature found: %s"),feature)
 self.server_features.append(feature)
 for cat, type in disco.identities:
-debug ("Identity found: [%s/%s] %s" % (cat, type, disco.identities[(cat,type)]))
+debug (_("Identity found: [%(category)s/%(type)s] %(identity)s") % {'category':cat, 'type':type, 'identity':disco.identities[(cat,type)]})
 ## Generic HMI ##
 def actionResult(self, id, type, data):
 @param id: same id used with action
 @param type: result type /!\ only "DICT_DICT" for this method
 @param data: dictionary of dictionaries
 """
 if type != "DICT_DICT":
-error("type for actionResultExt must be DICT_DICT, fixing it")
+error(_("type for actionResultExt must be DICT_DICT, fixing it"))
 type = "DICT_DICT"
 self.bridge.actionResultExt(type, id, data)
 @param type: confirmation type ("YES/NO", "FILE_TRANSFERT")
 @param data: data (depend of confirmation type)
 @param cb: callback called with the answer
 """
 if self.__waiting_conf.has_key(id):
-error ("Attempt to register two callbacks for the same confirmation")
+error (_("Attempt to register two callbacks for the same confirmation"))
 else:
 self.__waiting_conf[id] = cb
 self.bridge.askConfirmation(type, id, data)
 def confirmationAnswer(self, id, accepted, data):
 """Called by frontends to answer confirmation requests"""
-debug ("Received confirmation answer for id [%s]: %s", id, "accepted" if accepted else "refused")
+debug (_("Received confirmation answer for id [%(id)s]: %(success)s") % {'id': id, 'success':u("accepted") if accepted else _("refused")})
 if not self.__waiting_conf.has_key(id):
-error ("Received an unknown confirmation")
+error (_("Received an unknown confirmation"))
 else:
 cb = self.__waiting_conf[id]
 del self.__waiting_conf[id]
 cb(id, accepted, data)
 self.__progress_cb_map[id] = CB
 def removeProgressCB(self, id):
 """Remove a progress callback"""
 if not self.__progress_cb_map.has_key(id):
-error ("Trying to remove an unknow progress callback")
+error (_("Trying to remove an unknow progress callback"))
 else:
 del self.__progress_cb_map[id]
 def getProgress(self, id):
 """Return a dict with progress information
 self.__general_cb_map[name] = CB
 def removeGeneralCB(self, name):
 """Remove a general callback"""
 if not self.__general_cb_map.has_key(name):
-error ("Trying to remove an unknow general callback")
+error (_("Trying to remove an unknow general callback"))
 else:
 del self.__general_cb_map[name]
 def callGeneralCB(self, name, *args, **kwargs):
 """Call general function back"""
 try:
 return self.__general_cb_map[name](*args, **kwargs)
 except KeyError:
-error("Trying to call unknown function")
+error(_("Trying to call unknown function"))
 return None
 application = service.Application('SàT')
 service = SAT()
 service.setServiceParent(application)

Mercurial > libervia-backend

comparison sat.tac @ 69:86f1f7f6d332