## along with Gajim. If not, see <http://www.gnu.org/licenses/>.

 ##

 from gi.repository import Gtk

 import gtkgui_helpers

 from common import gajim

 class Column(IntEnum):

     PREFERENCE_NAME = 0

     VALUE = 1

     @command('lastlog', overlap=True)

     @doc(_("Show logged messages which mention given text"))

     def grep(self, text, limit=None):

         if not results:

             raise CommandError(_("%s: Nothing found") % text)

                 raise CommandError(_("Limit must be an integer"))

         for row in results:

             if not contact:

                     contact = gajim.nicks[self.account]

                 else:

                     contact = self.contact.name

             date_ = strftime('%Y-%m-%d', time_obj)

             time_ = strftime('%H:%M:%S', time_obj)

             if date_obj == date.today():

             else:

             self.echo(formatted)

 import re

 from common import defs

 from gi.repository import GLib

 class Option(IntEnum):

     TYPE = 0

     VAL = 1

 import sys

 import tempfile

 from common import defs

 class Type(Enum):

     CONFIG = 0

     CACHE = 1

 import logging

 import os

 import threading

 import nbxmpp

 from common import gajim

 from common import configpaths

 log = logging.getLogger('gajim.c.jingle_ft')

 class State(IntEnum):

     NOT_STARTED = 0

     INITIALIZED = 1

 # * timeout

 import logging

 import nbxmpp

 from common import gajim

 from common.jingle_transport import get_jingle_transport, JingleTransportIBB

 log = logging.getLogger("gajim.c.jingle_session")

 # FIXME: Move it to JingleSession.States?

 class JingleStates(Enum):

     """

     States in which jingle session may exist

 import logging

 import socket

 import nbxmpp

 from common import gajim

         return transports[namespace](node)

 class TransportType(IntEnum):

     """

     Possible types of a JingleTransport

 import time

 import datetime

 import json

 from gzip import GzipFile

 from io import BytesIO

 from gi.repository import GLib

 from common import exceptions

 from common import gajim

 import logging

 log = logging.getLogger('gajim.c.logger')

 class JIDConstant(IntEnum):

     NORMAL_TYPE = 0

     ROOM_TYPE = 1

 class KindConstant(IntEnum):

     STATUS = 0

     GCSTATUS = 1

     CHAT_MSG_SENT = 6

     ERROR = 7

 class ShowConstant(IntEnum):

     ONLINE = 0

     CHAT = 1

     DND = 4

     OFFLINE = 5

 class TypeConstant(IntEnum):

     AIM = 0

     GG = 1

     MRIM = 13

     NO_TRANSPORT = 14

 class SubscriptionConstant(IntEnum):

     NONE = 0

     TO = 1

     def get_jids_already_in_db(self):

         try:

             self.cur.execute('SELECT jid FROM jids')

             rows = self.cur.fetchall()

         except sqlite.DatabaseError:

             raise exceptions.DatabaseMalformed

         """

         Accept how many rows to restore and when to time them out (in minutes)

         (mark them as too old) and number of messages that are in queue and are

         found to meet our demands

         """

         try:

         # returns time in seconds for the second that starts that date since epoch

         # gimme unixtime from year month day:

         d = datetime.date(year, month, day)

         # we have time since epoch baby :)

         start_of_day = int(time.mktime(local_time))

         return start_of_day

     def get_conversation_for_date(self, jid, year, month, day, account):

         """

         """

         try:

             self.get_jid_id(jid)

             ORDER BY time

             ''' % (where_sql, start_of_day, last_second_of_day), jid_tuple)

         """

         """

         try:

             self.get_jid_id(jid)

         where_sql, jid_tuple = self._build_contact_where(account, jid)

         like_sql = '%' + query.replace("'", "''") + '%'

             start_of_day = self.get_unix_time_from_date(year, month, day)

             seconds_in_a_day = 86400 # 60 * 60 * 24

             last_second_of_day = start_of_day + seconds_in_a_day - 1

             self.cur.execute('''

             WHERE (%s) AND message LIKE '%s'

             AND time BETWEEN %d AND %d

             ORDER BY time

                 jid_tuple)

         else:

             self.cur.execute('''

             WHERE (%s) AND message LIKE '%s'

             ORDER BY time

             ''' % (where_sql, like_sql), jid_tuple)

         return results

     def get_days_with_logs(self, jid, year, month, max_day, account):

 ## along with Gajim.  If not, see <http://www.gnu.org/licenses/>.

 ##

 class Constant(IntEnum):

     NAME = 0

     DOMAIN = 1

     BARE_NAME = 3

     TXT = 4

 class ConstantRI(IntEnum):

     INTERFACE = 0

     PROTOCOL = 1

 import os

 import time

 import gtkgui_helpers

 import tooltips

 import logging

 log = logging.getLogger('gajim.filetransfer_window')

 class Column(IntEnum):

     IMAGE = 0

     LABELS = 1

 import dataforms_widget

 import nbxmpp

 from common import events

 from common import gajim

 import logging

 log = logging.getLogger('gajim.groupchat_control')

 class Column(IntEnum):

     IMG = 0 # image to show state (online, new message etc)

     NICK = 1 # contact nickame or ROLE name

 from common import helpers

 import dialogs

 class Column(IntEnum):

     UNIXTIME = 2

     MESSAGE = 3

         # get those jids that have at least one entry in logs

         self.cur.execute('SELECT jid, jid_id FROM jids WHERE jid_id IN ('

                 'SELECT distinct logs.jid_id FROM logs) ORDER BY jid')

         rows = self.cur.fetchall()

         for row in rows:

             self.jids_already_in.append(row[0])  # jid

 import time

 import calendar

 import gtkgui_helpers

 import conversation_textview

 from common.logger import ShowConstant, KindConstant

 class InfoColumn(IntEnum):

     '''Completion dict'''

     JID = 0

     NAME = 2

     COMPLETION = 3

 class Column(IntEnum):

     LOG_JID = 0

     CONTACT_NAME = 1

             return

         year, month, day = self.calendar.get_date() # integers

         month = gtkgui_helpers.make_gtk_month_python_month(month)

     def on_calendar_month_changed(self, widget):

         """

         return show

         """

         """

         self.last_time_printout = 0

         show_status = self.show_status_checkbutton.get_active()

                 continue

             return

         buf = self.history_buffer

         end_iter = buf.get_end_iter()

             timestamp_str = gajim.config.get('time_stamp')

             timestamp_str = helpers.from_one_line(timestamp_str)

             tim = time.strftime(timestamp_str, time.localtime(float(tim)))

         elif gajim.config.get('print_time') == 'sometimes':

             every_foo_seconds = 60 * gajim.config.get(

                     'print_ichat_every_foo_minutes')

         if kind == KindConstant.GC_MSG:

             tag_name = 'incoming'

             contact_name = self.completion_dict[self.jid][InfoColumn.NAME]

             tag_name = 'incoming'

             tag_msg = 'incomingtxt'

             if self.account:

                 contact_name = gajim.nicks[self.account]

             else:

                 month = gtkgui_helpers.make_gtk_month_python_month(month)

             show_status = self.show_status_checkbutton.get_active()

             #FIXME:

             # add "subject:  | message: " in message column if kind is single

             # also do we need show at all? (we do not search on subject)

             for row in results:

                     continue

                 if not contact_name:

                         contact_name = gajim.nicks[account]

                     else:

                         contact_name = self.completion_dict[jid][InfoColumn.NAME]

                 date = time.strftime('%Y-%m-%d', local_time)

     def on_results_treeview_row_activated(self, widget, path, column):

         """

         cur_year, cur_month, cur_day = self.calendar.get_date()

         cur_month = gtkgui_helpers.make_gtk_month_python_month(cur_month)

         model = widget.get_model()

         tim = time.strptime(model[path][Column.UNIXTIME], '%Y-%m-%d')

         year = tim[0]

         gtk_month = tim[1]

         Derivded classes MUST implement this.

         """

         # return (label_str, None)

         pass

 from gi.repository import GLib, Gdk

 import os

 import gtkgui_helpers

 from dialogs import WarningDialog, YesNoDialog, ArchiveChooserDialog

 from plugins.plugins_i18n import _

 from common.exceptions import PluginsystemError

 class Column(IntEnum):

     PLUGIN = 0

     NAME = 1

 import time

 import locale

 import common.sleepy

 import history_window

 from nbxmpp.protocol import NS_FILE, NS_ROSTERX, NS_CONFERENCE

 class Column(IntEnum):

     IMG = 0  # image to show state (online, new message etc)

     NAME = 1  # cellrenderer text that holds contact nickame

         self._iters = {}

         # for merged mode

         self._iters['MERGED'] = {'account': None, 'groups': {}}

         self._last_selected_contact = []

         self.transports_state_images = {'16': {}, '32': {}, 'opened': {},

             'closed': {}}