PK ‚LHŸ%ìÒŽ Ž qdatamatrix/_qcell.py#-*- coding:utf-8 -*-
"""
This file is part of qdatamatatrix.
qdatamatatrix is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
qdatamatatrix is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with qdatamatatrix. If not, see .
"""
from datamatrix.py3compat import *
from qtpy.QtWidgets import QTableWidgetItem
from qtpy.QtCore import Qt
from qtpy.QtGui import QFont, QColor, QBrush
class QCell(QTableWidgetItem):
def __init__(self, val=u'', style=None):
QTableWidgetItem.__init__(self, safe_decode(val))
self._style = style
self.update_style()
def clone(self):
return self.__class__()
def set_header_style(self):
fnt = QFont()
fnt.setWeight(QFont.Black)
self.setFont(fnt)
self.setBackground(QBrush(QColor(u'#d3d7cf')))
@property
def style(self):
if self.row() == 0:
return u'header'
if self._style is None:
try:
float(self.text())
return u'numeric'
except:
return u'text'
return self._style
@style.setter
def style(self, style):
self._style = style
self.update_style()
def update_style(self):
self.setBackground(QBrush(QColor(u'#eeeeec')))
if self.style == u'numeric':
self.setTextAlignment(Qt.AlignRight)
elif self.style == u'text':
self.setTextAlignment(Qt.AlignLeft)
elif self.style == u'header':
self.setTextAlignment(Qt.AlignCenter)
self.set_header_style()
elif self.style == u'row':
self.setTextAlignment(Qt.AlignRight)
else:
raise Exception(u'Unknown style: %s' % self.style)
PK ZXLHnéÿÙ
qdatamatrix/decorators.py#-*- coding:utf-8 -*-
"""
This file is part of qdatamatatrix.
qdatamatatrix is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
qdatamatatrix is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with qdatamatatrix. If not, see .
"""
from datamatrix.py3compat import *
def disconnected(fnc):
def inner(self, *args, **kwdict):
try:
self.cellChanged.disconnect()
cellChanged = True
except:
cellChanged = False
retval = fnc(self, *args, **kwdict)
if cellChanged:
self.cellChanged.connect(self._on_cell_changed)
return retval
return inner
def silent(fnc):
def inner(self, *args, **kwdict):
_silent = self._silent
self._silent = True
retval = fnc(self, *args, **kwdict)
self._silent = _silent
return retval
return inner
def undoable(fnc):
"""
desc:
A decorator that adds the operations done by a function to the undo
stack.
"""
def inner(self, *args, **kwdict):
if self._auto_update:
undo = self._start_undo_action()
else:
undo = False
retval = fnc(self, *args, **kwdict)
if undo:
self._end_undo_action()
return retval
return inner
def fix_cursor(fnc):
"""
desc:
A decorator that preserves the cursor position.
"""
def inner(self, *args, **kwdict):
pos = self._cursor_pos
retval = fnc(self, *args, **kwdict)
self._cursor_pos = pos
return retval
return inner
PK ·iLH’ÆGOµ µ qdatamatrix/_qdatamatrix.py#-*- coding:utf-8 -*-
"""
This file is part of qdatamatatrix.
qdatamatatrix is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
qdatamatatrix is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with qdatamatatrix. If not, see .
"""
from datamatrix.py3compat import *
from qdatamatrix._qspreadsheet import QSpreadSheet
from qtpy import QtWidgets, QtCore
class QDataMatrix(QtWidgets.QWidget):
"""
desc:
QDataMatrix is the main widget for viewing DataMatrix objects.
"""
cellchanged = QtCore.pyqtSignal(int, int)
changed = QtCore.pyqtSignal()
def __init__(self, dm, parent=None):
"""
desc:
Constructor to initialize a QDataMatrix object.
arguments:
dm:
type: `DataMatrix`
keywords:
parent:
desc: A parent QWidget, or None for no parent.
type: [QWidget, None]
"""
QtWidgets.QWidget.__init__(self, parent=parent)
self._dm = dm
self._spreadsheet = QSpreadSheet(self)
self._layout = QtWidgets.QHBoxLayout(self)
self._layout.addWidget(self._spreadsheet)
self.refresh()
@property
def dm(self):
return self._dm
@dm.setter
def dm(self, dm):
self._dm = dm
def refresh(self):
"""
desc:
Refresh the widget to reflect changes in the associated
`DataMatrix`.
"""
self._spreadsheet.refresh()
PK ¬iFHA‡±-µ µ qdatamatrix/translate.py#-*- coding:utf-8 -*-
"""
This file is part of qdatamatatrix.
qdatamatatrix is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
qdatamatatrix is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with qdatamatatrix. If not, see .
"""
from datamatrix.py3compat import *
from qtpy.QtCore import QCoreApplication
if py3:
def _(s):
return QCoreApplication.translate(u'qdatamatrix', s)
else:
def _(s):
return QCoreApplication.translate(u'qdatamatrix', s,
encoding=QCoreApplication.UnicodeUTF8)
PK ¬iFHÔèZ¨
¨
qdatamatrix/_qcontextmenu.py#-*- coding:utf-8 -*-
"""
This file is part of qdatamatatrix.
qdatamatatrix is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
qdatamatatrix is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with qdatamatatrix. If not, see .
"""
from qtpy import QtWidgets, QtGui, QtCore
from qdatamatrix.translate import _
class QContextAction(QtWidgets.QAction):
def __init__(self, icon, title, menu, keyseq=None):
QtWidgets.QAction.__init__(self, QtGui.QIcon.fromTheme(icon), title,
menu)
if keyseq is not None:
self.setShortcut(QtGui.QKeySequence(keyseq))
self._menu = menu
self.triggered.connect(self.activate)
@property
def spreadsheet(self):
return self._menu._spreadsheet
def activate(self):
pass
class QCopyAction(QContextAction):
def __init__(self, menu):
QContextAction.__init__(self, u'edit-copy', _(u'Copy'), menu, u'Ctrl+C')
def activate(self):
self.spreadsheet._copy()
class QCutAction(QContextAction):
def __init__(self, menu):
QContextAction.__init__(self, u'edit-cut', _(u'Cut'), menu, u'Ctrl+X')
def activate(self):
self.spreadsheet._cut()
class QPasteAction(QContextAction):
def __init__(self, menu):
QContextAction.__init__(self, u'edit-paste', _(u'paste'), menu,
u'Ctrl+V')
def activate(self):
self.spreadsheet._paste()
class QRemoveRowAction(QContextAction):
def __init__(self, menu):
n = len(menu._spreadsheet._selected_rows)
QContextAction.__init__(self, u'list-remove',
_(u'Remove %d row(s)') % n, menu)
def activate(self):
self.spreadsheet._remove_rows()
class QRemoveColumnAction(QContextAction):
def __init__(self, menu):
n = len(menu._spreadsheet._selected_columns)
QContextAction.__init__(self, u'list-remove',
_(u'Remove %d column(s)') % n, menu)
def activate(self):
self.spreadsheet._remove_columns()
class QContextMenu(QtWidgets.QMenu):
def __init__(self, spreadsheet=None):
QtWidgets.QMenu.__init__(self, parent=spreadsheet)
self._spreadsheet = spreadsheet
self.addAction(QCutAction(self))
self.addAction(QCopyAction(self))
self.addAction(QPasteAction(self))
self.addSeparator()
if spreadsheet._selected_rows:
self.addAction(QRemoveRowAction(self))
if spreadsheet._selected_columns:
self.addAction(QRemoveColumnAction(self))
PK ÔYLH¾Ùy+Y# Y# qdatamatrix/_qspreadsheet.py#-*- coding:utf-8 -*-
"""
This file is part of qdatamatatrix.
qdatamatatrix is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
qdatamatatrix is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with qdatamatatrix. If not, see .
"""
from datamatrix.py3compat import *
from qdatamatrix.decorators import undoable, disconnected, fix_cursor, silent
from qdatamatrix._qcell import QCell
from qdatamatrix._qcelldelegate import QCellDelegate
from qtpy import QtWidgets, QtGui, QtCore
class QSpreadSheet(QtWidgets.QTableWidget):
"""
desc:
QSpreadSheet implements the table/ spreadsheet of a QDataMatrix. It's
created automatically by QDataMatrix.
"""
def __init__(self, qdm=None):
QtWidgets.QTableWidget.__init__(self, parent=qdm)
self._qdm = qdm
self._undo_stack = []
self._in_undo_action = False
self._auto_update = True
self._silent = False
self._shortcut(u'Ctrl+Z', self._undo)
self._shortcut(u'Ctrl+C', self._copy)
self._shortcut(u'Ctrl+V', self._paste)
self._shortcut(u'Ctrl+X', self._cut)
# self._shortcut(u'Ctrl+P', self._print)
self._shortcut(u'Del', self._delete)
# The cell delegate captures left/ right keypresses so that these
# immediately move the cursor
self.delegate = QCellDelegate(self)
self.delegate.move.connect(self._move)
self.setItemDelegate(self.delegate)
# The custom cell object is necessary for styling
self.setItemPrototype(QCell())
self.horizontalHeader().hide()
self.cellChanged.connect(self._on_cell_changed)
def _print(self):
print(self.dm)
def _shortcut(self, keyseq, target):
QtWidgets.QShortcut(QtGui.QKeySequence(keyseq), self, target,
context=QtCore.Qt.WidgetWithChildrenShortcut)
@property
def dm(self):
return self._qdm.dm
@dm.setter
def dm(self, dm):
self._qdm.dm = dm
@silent
@fix_cursor
@disconnected
def refresh(self):
self.clear()
self._adjust_size()
for colnr, (name, col) in enumerate(self.dm.columns):
self._setcell(0, colnr, name)
for rownr, val in enumerate(col):
self._setcell(rownr+1, colnr, val)
# Overridden functions
def contextMenuEvent(self, e):
"""
desc:
Shows a context menu.
arguments:
e:
type: QContextMenuEvent
"""
from qdatamatrix._qcontextmenu import QContextMenu
QContextMenu(self).exec_(e.globalPos())
# Private functions
def _adjust_size(self):
self.setColumnCount((1+(len(self.dm.columns)+50) // 100) * 100)
self.setRowCount(1 + (1+(len(self.dm)+50) // 100) * 100)
self.setVerticalHeaderLabels([u'']+ \
[str(i) for i in range(1, len(self.dm)+1)]+ \
[u'']*(self.rowCount()-len(self.dm)-1))
def _move(self, drow, dcol):
"""
desc:
Move the cursor, i.e. the selected cell.
arguments:
dRow:
desc: The number of rows to move.
type: int
dCol:
desc: The number of columns to move.
type: int
"""
row = max(0, self.currentRow()+drow)
col = max(0, self.currentColumn()+dcol)
self.setCurrentCell(row, col)
@property
def _selected_columns(self):
return sorted(set([i.column() for i in self.selectedIndexes() \
if i.column() < len(self.dm.columns)]))
@property
def _selected_rows(self):
return sorted(set([i.row()-1 for i in self.selectedIndexes() \
if i.row() > 0 and i.row() <= len(self.dm)]))
@property
def _clipboard(self):
return QtWidgets.QApplication.clipboard()
@property
def _cursor_pos(self):
return self.currentRow(), self.currentColumn()
@_cursor_pos.setter
def _cursor_pos(self, pos):
self.setCurrentCell(pos[0], pos[1])
def _column_by_index(self, colnr):
return self.dm.columns[colnr][1]
def _add_columns(self, colnr):
for i in range(len(self.dm.columns), colnr+1):
self.dm[self._unique_name] = u''
item = self.item(0, i)
if item is None:
self._setcell(0, i, self.dm.column_names[i])
for rownr in range(1, len(self.dm)+1):
item = self.item(rownr, i)
if item is None:
self._setcell(rownr, i)
self._adjust_size()
def _add_rows(self, rownr):
for i in range(self.dm.length, rownr+1):
for colnr in range(len(self.dm.columns)):
item = self.item(i, colnr)
if item is None:
self._setcell(i, colnr)
self.dm.length = rownr
self._adjust_size()
@undoable
def _remove_columns(self):
for colnr in self._selected_columns[::-1]:
del self.dm[self.dm.column_names[colnr]]
self.refresh()
self._qdm.changed.emit()
@undoable
def _remove_rows(self):
for row in self._selected_rows[::-1]:
del self.dm[row]
self.refresh()
self._qdm.changed.emit()
def _rename_column(self, colnr):
old_name = self.dm.column_names[colnr]
new_name = self._value(0, colnr)
try:
self.dm.rename(old_name, new_name)
self._qdm.changed.emit()
except ValueError as e:
self._setcell(0, colnr, old_name)
def _change_cell(self, rownr, colnr):
self._column_by_index(colnr)[rownr-1] = self._value(rownr, colnr)
@disconnected
@undoable
def _on_cell_changed(self, rownr, colnr):
if colnr >= len(self.dm.columns):
self._add_columns(colnr)
if rownr > len(self.dm):
self._add_rows(rownr)
if rownr == 0:
self._rename_column(colnr)
else:
self._change_cell(rownr, colnr)
self.item(rownr, colnr).update_style()
if not self._silent:
self._qdm.cellchanged.emit(rownr, colnr)
self._qdm.changed.emit()
def _setcell(self, rownr, colnr, val=u''):
item = self.item(rownr, colnr)
if item is None:
item = QCell(val)
self.setItem(rownr, colnr, item)
else:
item.setText(safe_decode(val))
item.update_style()
@property
def _unique_name(self):
i = 1
while True:
name = u'new_column_%d' % i
if name not in self.dm.column_names:
return name
i += 1
def _value(self, rownr, colnr):
return self.item(rownr, colnr).text()
def _undo(self):
"""
desc:
Reverts to the last state of the undo stack (if any).
"""
self._in_undo_action = True
if len(self._undo_stack) == 0:
self._in_undo_action = False
return
self._cursor_pos, self.dm = self._undo_stack.pop()
self._in_undo_action = False
self.refresh()
def _start_undo_action(self):
"""
desc:
Starts an undo action.
"""
if self._in_undo_action:
return False
self._add_undo_history()
self._in_undo_action = True
return True
def _end_undo_action(self):
"""
desc:
Ends an undo action.
"""
self._in_undo_action = False
def _clear_undo(self):
"""
desc:
Clears the undo stack.
"""
self._undo_stack = []
def _add_undo_history(self):
"""
desc:
Adds the current state to the undo stack.
"""
if not self._in_undo_action:
self._undo_stack.append( (self._cursor_pos, self.dm[:]) )
@undoable
def _cut(self):
"""
desc:
Copies the current selection to the clipboard, and then clears the
current selection.
"""
self._copy(clear=True)
@undoable
def _delete(self):
"""
desc:
Clears the current selection.
"""
self._copy(clear=True, copy=False)
def _copy(self, clear=False, copy=True):
"""
desc:
Copies the current selection to the clipboard.
keywords:
clear:
desc: Indicates whether copied cells should be cleared.
type: bool
copy:
desc: Indicates whether cells should be copied to the
clipboard.
type: bool
"""
# Get the start and end of the selection
l = self.selectedRanges()
if len(l) == 0:
return
firstrow = min([r.topRow() for r in l])
firstcolnr = min([r.leftColumn() for r in l])
lastrow = max([r.bottomRow() for r in l])
lastcolnr = max([r.rightColumn() for r in l])
colspan = lastcolnr - firstcolnr + 1
rowspan = lastrow - firstrow + 1
# Create an empty list of lists, where the value __empty__ indicates
# that there's nothing in it (not even an empty string). This allows us
# to deal with non-contiguous selections.
matrix = []
for col in range(rowspan):
matrix.append([u'__empty__']*colspan)
# Add all selected cells.
for item in self.selectedItems():
row = self.row(item)-firstrow
colnr = self.column(item)-firstcolnr
matrix[row][colnr] = item.text()
if clear:
self._setcell(self.row(item), self.column(item))
# Convert the selection to text and put it on the clipboard
txt = u'\n'.join([u'\t'.join(_col) for _col in matrix])
if copy:
self._clipboard.setText(txt)
@undoable
def _paste(self):
"""
desc:
Pastes the current clipboard contents onto the DataFrame.
"""
txt = self._clipboard.mimeData().text()
rows = txt.split(u'\n')
for i, row in enumerate(rows):
cells = row.split(u'\t')
for j, cell in enumerate(cells):
self._setcell(self.currentRow()+i, self.currentColumn()+j, cell)
PK c^{HÕi±Ö qdatamatrix/__init__.py#-*- coding:utf-8 -*-
"""
This file is part of qdatamatatrix.
qdatamatatrix is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
qdatamatatrix is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with qdatamatatrix. If not, see .
"""
__version__ = '0.1.4'
from datamatrix.py3compat import *
from qdatamatrix._qdatamatrix import QDataMatrix
PK §iFHσm§E E qdatamatrix/_qcelldelegate.py#-*- coding:utf-8 -*-
"""
This file is part of qdatamatatrix.
qdatamatatrix is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
qdatamatatrix is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with qdatamatatrix. If not, see .
"""
from qtpy.QtWidgets import QStyledItemDelegate
from qtpy.QtCore import Qt, QEvent, pyqtSignal
class QCellDelegate(QStyledItemDelegate):
"""
desc:
A delegate that intercepts left and right keypresses to move to previous
and next cells in the table.
"""
move = pyqtSignal(int, int)
def eventFilter(self, lineEdit, e):
if e.type() == QEvent.KeyPress:
if e.key() in [Qt.Key_Left, Qt.Key_Right]:
self.commitData.emit(lineEdit)
self.closeEditor.emit(lineEdit, self.NoHint)
if e.key() == Qt.Key_Left:
self.move.emit(0, -1)
else:
self.move.emit(0, 1)
return True
return QStyledItemDelegate.eventFilter(self, lineEdit, e)
PK L{H^-Ò
2 python_qdatamatrix-0.1.4.dist-info/DESCRIPTION.rstUNKNOWN
PK L{HH~¾µ: : 0 python_qdatamatrix-0.1.4.dist-info/metadata.json{"classifiers": ["Development Status :: 4 - Beta", "Intended Audience :: Science/Research", "Topic :: Scientific/Engineering", "License :: OSI Approved :: GNU General Public License v3 (GPLv3)", "Programming Language :: Python :: 2", "Programming Language :: Python :: 3"], "extensions": {"python.details": {"contacts": [{"email": "s.mathot@cogsci.nl", "name": "Sebastiaan Mathot", "role": "author"}], "document_names": {"description": "DESCRIPTION.rst"}, "project_urls": {"Home": "https://github.com/smathot/python-qdatamatrix"}}}, "extras": [], "generator": "bdist_wheel (0.26.0)", "license": "GNU GPL Version 3", "metadata_version": "2.0", "name": "python-qdatamatrix", "run_requires": [{"requires": ["python-datamatrix"]}], "summary": "A PyQt4/PyQt5 widget for viewing and editing a DataMatrix object", "version": "0.1.4"}PK L{Hq†„ 0 python_qdatamatrix-0.1.4.dist-info/top_level.txtqdatamatrix
PK L{Hìndªn n ( python_qdatamatrix-0.1.4.dist-info/WHEELWheel-Version: 1.0
Generator: bdist_wheel (0.26.0)
Root-Is-Purelib: true
Tag: py2-none-any
Tag: py3-none-any
PK L{H1Œ ˆ‹ ‹ + python_qdatamatrix-0.1.4.dist-info/METADATAMetadata-Version: 2.0
Name: python-qdatamatrix
Version: 0.1.4
Summary: A PyQt4/PyQt5 widget for viewing and editing a DataMatrix object
Home-page: https://github.com/smathot/python-qdatamatrix
Author: Sebastiaan Mathot
Author-email: s.mathot@cogsci.nl
License: GNU GPL Version 3
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Science/Research
Classifier: Topic :: Scientific/Engineering
Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 3
Requires-Dist: python-datamatrix
UNKNOWN
PK L{HåÒK}È È ) python_qdatamatrix-0.1.4.dist-info/RECORDpython_qdatamatrix-0.1.4.dist-info/DESCRIPTION.rst,sha256=OCTuuN6LcWulhHS3d5rfjdsQtW22n7HENFRh6jC6ego,10
python_qdatamatrix-0.1.4.dist-info/METADATA,sha256=wuJPRB-GqMdichJfKV59StxKZtX_xgFDSfhhQdGOZdQ,651
python_qdatamatrix-0.1.4.dist-info/RECORD,,
python_qdatamatrix-0.1.4.dist-info/WHEEL,sha256=GrqQvamwgBV4nLoJe0vhYRSWzWsx7xjlt74FT0SWYfE,110
python_qdatamatrix-0.1.4.dist-info/metadata.json,sha256=ZDPLkajnUOi78DRIpozPEbtGY5Mbrj5oWsxfTeKEEEA,826
python_qdatamatrix-0.1.4.dist-info/top_level.txt,sha256=caJK4WoGVIvVGeKW-UM-78T6yQgjf9P6pehrw7VN5to,12
qdatamatrix/__init__.py,sha256=RNrXB8kx2D2Rv1xBo3ismbqFeBbSkthx-EefIxsZ9l8,791
qdatamatrix/_qcell.py,sha256=xeXhdBh7GX3YQ7Gt3i-jWYDI2yQPctr2_H_hH7Y-0gk,1934
qdatamatrix/_qcelldelegate.py,sha256=_6AB3BGSC9dbSZP6z86mOxC9d2WawCB3OqiHCmHzDCE,1349
qdatamatrix/_qcontextmenu.py,sha256=irIMKNmN229jr3QOFHvPoiyUqsx3PGldzgHExVeRCeE,2728
qdatamatrix/_qdatamatrix.py,sha256=mHdvbA6oqMex3G6JAtS9KTGh3Mzs3Oh2buLxXATHOi8,1717
qdatamatrix/_qspreadsheet.py,sha256=xVl3SiRaGkzXAp29RFRTQkbh6azrTC19UC6EkN41qYY,9049
qdatamatrix/decorators.py,sha256=dWpwqgujFnWXEyE2oLKOxTKzeSTaFj6umnG0o-c2VmE,1802
qdatamatrix/translate.py,sha256=xYR23NJtej7gZvXqjl712mtDO4Vf4fPTVAHvAXHGct8,949
PK ‚LHŸ%ìÒŽ Ž qdatamatrix/_qcell.pyPK ZXLHnéÿÙ
Á qdatamatrix/decorators.pyPK ·iLH’ÆGOµ µ qdatamatrix/_qdatamatrix.pyPK ¬iFHA‡±-µ µ ð qdatamatrix/translate.pyPK ¬iFHÔèZ¨
¨
Û qdatamatrix/_qcontextmenu.pyPK ÔYLH¾Ùy+Y# Y# ½$ qdatamatrix/_qspreadsheet.pyPK c^{HÕi±Ö PH qdatamatrix/__init__.pyPK §iFHσm§E E œK qdatamatrix/_qcelldelegate.pyPK L{H^-Ò
2 Q python_qdatamatrix-0.1.4.dist-info/DESCRIPTION.rstPK L{HH~¾µ: : 0 vQ python_qdatamatrix-0.1.4.dist-info/metadata.jsonPK L{Hq†„ 0 þT python_qdatamatrix-0.1.4.dist-info/top_level.txtPK L{Hìndªn n ( XU python_qdatamatrix-0.1.4.dist-info/WHEELPK L{H1Œ ˆ‹ ‹ + V python_qdatamatrix-0.1.4.dist-info/METADATAPK L{HåÒK}È È ) àX python_qdatamatrix-0.1.4.dist-info/RECORDPK _ ï]