def __init__(self): super().__init__() self.RootWidth = 1000 self.RootHeight = 625 if os.name == 'nt': self.LogPath = r"C:\temp\File_tools.json" self.LogPathBackup = r'C:\Windows\Temp\File_tools_backup.json' else: self.LogPath = r"/temp/File_tools.json" self.LogPathBackup = r'/temp/File_tools_backup.json' self.IsFirstTimeOpen = 1 self.firewall_add_rules_savefile = r'firewall_add_rules_savefile.txt' self.EnableLog = 1 self.CheckPathExist = 1 self.AdvancedMode = 0 self.bl = lib.baselib.BaseLib() self.fl = lib.filelib.FileLib() self.tl = lib.txtlib.TxtLib() self.fwl = lib.firewalllib.FirewallLib() self.rl = lib.rarlib.RarLib() self.natsort_key1 = natsort_keygen(key=lambda y: y.lower()) # l1.sort(key=self.natsort_key1) # lower means lowerCase -> upperCase self.natsort_key2 = natsort_keygen(alg=ns.IGNORECASE) # l2.sort(key=self.natsort_key2)
def test_natsort_keygen_with_invalid_alg_input_raises_ValueError():
# Invalid arguments give the correct response
with raises(ValueError) as err:
natsort_keygen(None, '1')
assert str(
err.value
) == "natsort_keygen: 'alg' argument must be from the enum 'ns', got 1"
def test_natsort_keygen_splits_input_with_locale_and_capitalfirst():
load_locale('en_US')
strxfrm = get_strxfrm()
with patch('natsort.compat.locale.dumb_sort', return_value=False):
assert natsort_keygen(alg=ns.LA | ns.C)(INPUT) == ((('',), (null_string_locale, 6, strxfrm('A-'), 5, strxfrm('.'), 34, strxfrm('e+'), 1)), (('/',), (strxfrm('/Folder ('), 1, strxfrm(')/Foo'))), (('',), (null_string_locale, 56.7)))
if PY_VERSION >= 3: assert natsort_keygen(alg=ns.LA | ns.C)(b'6A-5.034e+1') == (b'6A-5.034e+1',)
locale.setlocale(locale.LC_ALL, str(''))
def sort_subdirs(self, albums_sort_attr):
if self.subdirs:
if albums_sort_attr:
root_path = self.path if self.path != '.' else ''
if albums_sort_attr.startswith("meta."):
meta_key = albums_sort_attr.split(".", 1)[1]
def sort_key(s):
album = self.gallery.albums[join(root_path, s)]
return album.meta.get(meta_key, [''])[0]
else:
def sort_key(s):
album = self.gallery.albums[join(root_path, s)]
return getattr(album, albums_sort_attr)
key = natsort_keygen(key=sort_key, alg=ns.LOCALE)
else:
key = natsort_keygen(alg=ns.LOCALE)
self.subdirs.sort(key=key,
reverse=self.settings['albums_sort_reverse'])
signals.albums_sorted.send(self)
def __init__(self, my_book, parent=None):
super().__init__(parent)
# Save access to the book, get ref to worddata
self.my_book = my_book
self.words = my_book.get_word_model()
# Go create all the layout stuff. This creates the members:
# self.view the WordTableView object
# self.model the WordTableModel object
# self.refresh the Refresh button
# self.sw_case the Respect Case toggle
# self.popup the filter popup
# self.row_count the label showing count of rows
# self.progress a QProgressDialog used during refresh
# self.good_model good words model
# self.good_view good words list view
self._uic()
# Set up locale-aware sort key functions from natsort
self.case_yes_func = natsort.natsort_keygen(
alg = ( natsort.ns.LOCALE | natsort.ns.UNGROUPLETTERS | natsort.ns.UNSIGNED | natsort.ns.INT ) )
self.case_no_func = natsort.natsort_keygen(
alg = ( natsort.ns.IGNORECASE | natsort.ns.LOCALE | natsort.ns.UNSIGNED | natsort.ns.INT ) )
# Connect all the various signals to their slots:
# Refresh button to do_refresh()
self.refresh.clicked.connect(self.do_refresh)
# Popup choice changes filtering of table
self.popup.activated.connect(self.do_filter)
# change of Respect Case changes sorting of table
self.sw_case.stateChanged.connect(self.do_set_case)
self.sw_case.setChecked(True) # start out case-sensitive
# Change of model to be reflected in row_count label
self.model.layoutChanged.connect(self.do_row_count)
# double-click of a table row to do_find()
self.view.doubleClicked.connect(self.do_find)
# Connect worddata changes due to metadata input
self.words.WordsUpdated.connect(self.do_update)
def test_natsort_keygen_splits_input_with_path():
assert natsort_keygen(alg=ns.P | ns.G)(INPUT) == (
(("", 6, "aA--", 5, "..", 34, "ee++", 1),),
(("//",), ("fFoollddeerr ((", 1, "))"), ("fFoooo",)),
(("", 56.7),),
)
if PY_VERSION >= 3:
assert natsort_keygen(alg=ns.P | ns.G)(b"6A-5.034e+1") == ((b"6A-5.034e+1",),)
def test_natsort_keygen_splits_input_with_ignorecase():
assert natsort_keygen(alg=ns.IC)(INPUT) == (
("", 6, "a-", 5, ".", 34, "e+", 1),
("/folder (", 1, ")/foo"),
("", 56.7),
)
if PY_VERSION >= 3:
assert natsort_keygen(alg=ns.IC)(b"6A-5.034e+1") == (b"6a-5.034e+1",)
def test_natsort_keygen_splits_input_with_lowercasefirst_noexp_float():
assert natsort_keygen(alg=ns.LF | ns.F
| ns.N)(INPUT) == (('', 6.0, 'a-', 5.034, 'E+', 1.0),
('/fOLDER (', 1.0,
')/fOO'), ('', 56.7))
if PY_VERSION >= 3:
assert natsort_keygen(alg=ns.LF | ns.F
| ns.N)(b'6A-5.034e+1') == (b'6A-5.034e+1', )
def test_natsort_keygen_splits_input_with_lowercasefirst_noexp_float():
assert natsort_keygen(alg=ns.LF | ns.F | ns.N)(INPUT) == (
("", 6.0, "a-", 5.034, "E+", 1.0),
("/fOLDER (", 1.0, ")/fOO"),
("", 56.7),
)
if PY_VERSION >= 3:
assert natsort_keygen(alg=ns.LF | ns.F | ns.N)(b"6A-5.034e+1") == (b"6A-5.034e+1",)
def test_natsort_keygen_splits_input_with_locale():
load_locale('en_US')
strxfrm = get_strxfrm()
with patch('natsort.compat.locale.dumb_sort', return_value=False):
assert natsort_keygen(alg=ns.L)(INPUT) == ((null_string_locale, 6, strxfrm('A-'), 5, strxfrm('.'), 34, strxfrm('e+'), 1), (strxfrm('/Folder ('), 1, strxfrm(')/Foo')), (null_string_locale, 56.7))
with patch('natsort.compat.locale.dumb_sort', return_value=True):
assert natsort_keygen(alg=ns.L)(INPUT) == ((null_string_locale, 6, strxfrm('aa--'), 5, strxfrm('..'), 34, strxfrm('eE++'), 1), (strxfrm('//ffoOlLdDeErR (('), 1, strxfrm('))//ffoOoO')), (null_string_locale, 56.7))
if PY_VERSION >= 3: assert natsort_keygen(alg=ns.LA)(b'6A-5.034e+1') == (b'6A-5.034e+1',)
locale.setlocale(locale.LC_ALL, str(''))
def __init__(self): super().__init__() try: self.bl = lib.baselib.BaseLib() except: self.bl = baselib.BaseLib() self.natsort_key1 = natsort_keygen(key=lambda y: y.lower()) # l1.sort(key=self.natsort_key1) # lower means lowerCase -> upperCase self.natsort_key2 = natsort_keygen(alg=ns.IGNORECASE) # l2.sort(key=self.natsort_key2)
def test_natsort_keygen_splits_input_with_path():
assert natsort_keygen(alg=ns.P | ns.G)(INPUT) == ((('', 6, 'aA--', 5, '..',
34, 'ee++', 1), ),
(('//', ),
('fFoollddeerr ((', 1,
'))'), ('fFoooo', )),
(('', 56.7), ))
if PY_VERSION >= 3:
assert natsort_keygen(alg=ns.P
| ns.G)(b'6A-5.034e+1') == ((b'6A-5.034e+1', ), )
def test_natsort_keygen_splits_input_with_locale_and_capitalfirst():
load_locale("en_US")
strxfrm = get_strxfrm()
with patch("natsort.compat.locale.dumb_sort", return_value=False):
assert natsort_keygen(alg=ns.LA | ns.C)(INPUT) == (
(("",), (null_string, 6, strxfrm("A-"), 5, strxfrm("."), 34, strxfrm("e+"), 1)),
(("/",), (strxfrm("/Folder ("), 1, strxfrm(")/Foo"))),
(("",), (null_string, 56.7)),
)
if PY_VERSION >= 3:
assert natsort_keygen(alg=ns.LA | ns.C)(b"6A-5.034e+1") == (b"6A-5.034e+1",)
locale.setlocale(locale.LC_ALL, str(""))
def fix_numbers(path):
doc_numbers_to_change = []
page_numbers_to_change = []
for subdir, dirs, files in os.walk(path):
dirs.sort(key=natsort_keygen())
if not any(
regex.search(r"-.+-", fname) for fname in os.listdir(subdir)):
continue
operat = os.path.basename(subdir)
if "merge" in subdir:
operat = os.path.basename(os.path.dirname(subdir))
doc_number = 1
for file in natsorted(files):
if regex.search(r"-.+-.+.PDF", file.upper()):
tail = file.split(operat)[1]
file_doc_number = tail.strip("_").split("-", 1)[0]
if int(file_doc_number) != doc_number:
doc_numbers_to_change.append(f"{subdir}\t{file} --> \
_--_{operat}_{doc_number}-{tail.strip('_').split('-', 1)[1]}")
doc_number += 1
if doc_numbers_to_change:
changes("dokumentów", doc_numbers_to_change)
for subdir, dirs, files in os.walk(path):
dirs.sort(key=natsort_keygen())
if not any(
regex.search(r"-.+-", fname) for fname in os.listdir(subdir)):
continue
operat = os.path.basename(subdir)
if "merge" in subdir:
operat = os.path.basename(os.path.dirname(subdir))
names_seen = {}
for file in natsorted(files):
if regex.search(r"-.+-.+.PDF", file.upper()):
tail = file.split(operat)[1]
file_type = regex.search(r"[A-Z].*[A-Z]",
tail.split(".")[0])[0]
file_page_number = tail.split(".")[0].split("-")[-1]
if file_type not in names_seen:
names_seen[file_type] = 1
else:
names_seen[file_type] += 1
if file_page_number != str(names_seen[file_type]).zfill(3):
page_numbers_to_change.append(f"{subdir}\t{file} --> \
_--_{operat}{tail.split(file_page_number)[0]}{str(names_seen[file_type]).zfill(3)}\
{tail.split(file_page_number)[1]}")
if page_numbers_to_change:
changes("stron", page_numbers_to_change)
if not doc_numbers_to_change and not page_numbers_to_change:
print(" --- NAJPIERW POPRAW --- ")
else:
print(" --- GOTOWE --- ")
def __init__(self):
super().__init__()
try:
self.bl = lib.baselib.BaseLib()
except:
self.bl = baselib.BaseLib()
self.dict = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-_+=~`[]{}|\\:;'\"<>,.?/ "
self.natsort_key1 = natsort_keygen(
key=lambda y: y.lower()
) # l1.sort(key=self.natsort_key1) # lower means lowerCase -> upperCase
self.natsort_key2 = natsort_keygen(
alg=ns.IGNORECASE) # l2.sort(key=self.natsort_key2)
def check_for_map_or_sketch(path):
possible_maps = ["'-M-PROJ-'", "'-M-WPROJ-'", "'-M-UZ-'", "'-M-WYN-'"]
sketch_coords = ["'-SZK-POL-'", "'-W-WSP-'"]
again = "t"
print()
while again == "t":
print_results = []
for subdir, dirs, _ in os.walk(path):
dirs.sort(key=natsort_keygen())
if any(
regex.search(r"-.+-", fname) for fname in os.listdir(subdir)
):
operat = os.path.basename(subdir)
if "merge" in subdir:
operat = os.path.basename(os.path.dirname(subdir))
for item in sketch_coords:
if not any(
item.strip("'") in fname.upper()
for fname in os.listdir(subdir)
):
print_results.append(f"{operat} nie zawiera {item}.")
if not any(
possibility.strip("'") in fname
for possibility in possible_maps
for fname in os.listdir(subdir)
):
missing_map = ", ".join(maps for maps in possible_maps)
print_results.append(
f"{operat} nie zawiera żadnej z map: {missing_map}."
)
for result in sorted(set(print_results)):
print(result)
print("Powtórzyć? t/n\n> ", end="")
again = msvcrt.getwche().lower()
print("\n")
def test_natsort_keygen_with_key_returns_same_result_as_nested_lambda_with_bare_natsort_key():
a = 'a-5.034e1'
f1 = natsort_keygen(key=lambda x: x.upper())
def f2(x):
return _natsort_key(x, lambda y: y.upper(), ns.F)
assert f1(a) == f2(a)
def get_pages(file):
try:
shutil.rmtree('/tmp/pages')
except OSError:
pass
os.mkdir('/tmp/pages')
r = requests.get(file)
try:
os.remove('/tmp/file')
except OSError:
pass
with open('/tmp/file', 'wb') as f:
f.write(r.content)
PDFExtractor.get_pages('/tmp/file', '/tmp/pages')
pages = []
dir_pages = os.listdir('/tmp/pages')
natsort_key = natsort_keygen(alg=ns.IGNORECASE)
dir_pages.sort(key=natsort_key)
for page in dir_pages:
dst = os.path.join('/tmp/pages', page)
key = '{}-{}.pdf'.format(
page,
datetime.datetime.fromtimestamp(
time.time()).strftime('%Y-%m-%d %H:%M:%S'))
upload(dst, pages_bucket, key)
# https://s3.amazonaws.com/ocr-lambda-pages/file_page_2.pdf-2018-09-24+19%3A31%3A03.pdf
pages.append('https://s3.amazonaws.com/{}/{}'.format(
pages_bucket, key))
return pages
def keymap(self):
"""Must be set to a KeyMap object; provides a help text"""
# Make sure the TUI (and ergo the keymap) is loaded
from .tui import main
km = self._keymap
lines = []
if km is None:
lines.append('Keybindings have not been loaded.')
else:
def stringify(s):
return ' '.join(s) if not isinstance(s, str) else s
for context in sorted(km.contexts,
key=lambda c: '' if c is None else c):
if context is None:
lines.append('GENERAL KEYBINDINGS')
else:
lines.append('{} KEYBINDINGS'.format(context.upper()))
keymap = ((key, stringify(action))
for key, action in km.map(context))
# Sort by command
from natsort import (natsort_keygen, natsorted, ns)
get_cmd = natsort_keygen(key=lambda pair: pair[1],
alg=ns.IGNORECASE)
for key, action in natsorted(keymap, key=get_cmd):
lines.append('\t{} \t{}'.format(key, action))
lines.append('')
return finalize_lines(lines)
class DragenSample(BaseSample):
natsort_key = natsort_keygen()
def __init__(self, **kwargs):
BaseSample.__init__(self, **kwargs) # name, dirpath, work_dir, bam, vcf, phenotype, normal_match
self.qc_files = []
self.bam = None
def sort_subdirs(self, albums_sort_attr):
if self.subdirs:
if not albums_sort_attr:
albums_sort_attr = self.settings['albums_sort_attr']
reverse = self.settings['albums_sort_reverse']
if 'sort' in self.meta:
albums_sort_attr = self.meta['sort'][0]
if albums_sort_attr[0] == '-':
albums_sort_attr = albums_sort_attr[1:]
reverse = True
else:
reverse = False
root_path = self.path if self.path != '.' else ''
if albums_sort_attr.startswith("meta."):
meta_key = albums_sort_attr.split(".", 1)[1]
def sort_key(s):
album = self.gallery.albums[join(root_path, s)]
return album.meta.get(meta_key, [''])[0]
else:
def sort_key(s):
album = self.gallery.albums[join(root_path, s)]
return getattr(album, albums_sort_attr)
key = natsort_keygen(key=sort_key, alg=ns.LOCALE)
self.subdirs.sort(key=key, reverse=reverse)
signals.albums_sorted.send(self)
def sort_devices(self):
natkey = natsort_keygen(key=device_key)
old_devices = copy.copy(self.devices)
self.devices.sort(key=natkey)
if self.devices != old_devices:
self._model.layoutChanged.emit()
def sort_medias(self, medias_sort_attr):
if self.medias:
if medias_sort_attr == 'date':
key = lambda s: s.date or datetime.now()
elif medias_sort_attr.startswith('meta.'):
meta_key = medias_sort_attr.split(".", 1)[1]
key = natsort_keygen(
key=lambda s: s.meta.get(meta_key, [''])[0], alg=ns.LOCALE)
else:
key = natsort_keygen(
key=lambda s: getattr(s, medias_sort_attr), alg=ns.LOCALE)
self.medias.sort(key=key,
reverse=self.settings['medias_sort_reverse'])
signals.medias_sorted.send(self)
def read_file_names(input_path):
# Read in file names
onlyfiles = [ f for f in listdir(input_path) if isfile(join(input_path,f))]
natsort_key1 = natsort_keygen(key = lambda y: y.lower()) # natural sorting order
onlyfiles.sort(key = natsort_key1)
return onlyfiles
def topic_keys(self):
"""Must be set to a KeyMap object; provides a help text"""
from .tui.tuiobjects import keymap
def stringify(s):
return ' '.join(s) if not isinstance(s, str) else s
lines = []
for context in sorted(keymap.contexts,
key=lambda c: '' if c is None else c):
if context is None:
lines.append('GENERAL KEYBINDINGS')
else:
lines.append('{} KEYBINDINGS'.format(context.upper()))
km = ((key, stringify(action))
for key, action in keymap.map(context))
# Sort by command
from natsort import (natsort_keygen, natsorted, ns)
get_cmd = natsort_keygen(key=lambda pair: pair[1],
alg=ns.IGNORECASE)
for key, action in natsorted(km, key=get_cmd):
if len(action) < 40:
lines.append(
'\t%s \t%s \t%s' %
(key, action, keymap.get_description(key, context)))
else:
lines.append('\t%s \t%s' % (key, action))
lines.append('\t \t%s' %
(keymap.get_description(key, context), ))
lines.append('')
return finalize_lines(lines)
def get_names(items: List) -> List[str]:
def key(name: str) -> Tuple[bool, str]:
return name == "", name
natkey = natsort_keygen(key=key)
names = sorted([i.name for i in items], key=natkey)
return names
def test_natsort_keygen_with_key_returns_same_result_as_nested_lambda_with_bare_natsort_key():
a = 'a-5.034e1'
f1 = natsort_keygen(key=lambda x: x.upper())
def f2(x):
return _natsort_key(x, lambda y: y.upper(), ns.I)
assert f1(a) == f2(a)
def switch_contigs(input_data):
"""Return the input data with 'chr' removed from contigs and X/Y changed to 23/24.
:param input_data: dict or pd.DataFrame with contig as keys or column
:returns: dict or pd.DataFrame with altered contig names"""
if type(input_data) == pd.DataFrame:
contig_column_names = ['Chr', 'Chromosome', 'Chrom', 'Contig'] # defines possible column names
contig_column_names = contig_column_names + [s.lower() for s in contig_column_names] + [s.upper() for s in contig_column_names] # accounts for all lower/upper-case
contig_column_names = contig_column_names + [s + 's' for s in contig_column_names] # pluralizes column names
column_idx = np.where([c in contig_column_names for c in input_data.columns])[0][0] # find contig column
column_label = input_data.columns[column_idx]
input_data[column_label] = input_data[column_label].apply(lambda x: re.search('(?<=chr)[0-9XY]+|^[0-9XY]+', x).group())
input_data.replace(to_replace={column_label:{'X':'23', 'Y':'24'}}, value=None, inplace=True)
input_data.sort_values(column_label, key=natsort.natsort_keygen(), inplace=True)
return input_data
elif type(input_data) == dict:
input_data = {re.search('(?<=chr)[0-9XY]+|^[0-9XY]+', key).group():loc for key, loc in input_data.items()}
if 'X' in input_data.keys():
input_data['23'] = input_data['X']
input_data.pop('X')
if 'Y' in input_data.keys():
input_data['24'] = input_data['Y']
input_data.pop('Y')
return input_data
else:
raise ValueError(f'Only dictionaries and pandas DataFrames supported. Not {type(input_data)}.')
def sort_channels(self):
natkey = natsort_keygen(key=channel_key)
old_channels = copy.copy(self.channels)
self.channels.sort(key=natkey)
if self.channels != old_channels:
self._model.layoutChanged.emit()
def __init__(
self,
nvs,
nv_model,
bus,
tx_id=0x1FFFFFFF,
rx_id=0x1FFFFFF7,
parent=None,
):
checkbox_columns = Columns.fill(False)
checkbox_columns.name = True
root = epyqlib.variableselectionmodel.Variables()
epyqlib.pyqabstractitemmodel.PyQAbstractItemModel.__init__(
self, root=root, checkbox_columns=checkbox_columns, parent=parent)
self.headers = Columns(
name="Name",
type="Type",
address="Address",
size="Size",
bits="Bits",
value="Value",
file="File",
)
self.nvs = nvs
self.nv_model = nv_model
self.bus = bus
self.git_hash = None
self.bits_per_byte = None
self.cache = None
self.pull_log_progress = epyqlib.utils.qt.Progress()
if self.nvs is not None:
signal = self.nvs.neo.signal_by_path("CCP", "Connect",
"CommandCounter")
self.protocol = ccp.Handler(
endianness="little" if signal.little_endian else "big",
tx_id=tx_id,
rx_id=rx_id,
)
from twisted.internet import reactor
self.transport = epyqlib.twisted.busproxy.BusProxy(
protocol=self.protocol, reactor=reactor, bus=self.bus)
else:
self.protocol = None
self.transport = None
# TODO: consider using locale? but maybe not since it's C code not
# raw strings
self.sort_key = natsort.natsort_keygen(alg=natsort.ns.IGNORECASE)
self.role_functions[epyqlib.utils.qt.UserRoles.sort] = self.data_sort
def check_if_all_named(path):
again = "t"
print()
while again == "t":
count = pdfs_to_name = 0
left_to_name = []
for subdir, dirs, _ in os.walk(path):
dirs.sort(key=natsort_keygen())
if regex.match(r"^.+04070...\.....", subdir):
get_steps = regex.match(r"^.+04070...\.....", subdir)[0]
else:
continue
if regex.search(r"04070...\.....$", get_steps):
steps_inside_path = len(get_steps.split("\\")) + 1
if len(subdir.split("\\")) == steps_inside_path:
up_to_merge = os.path.join(
subdir, os.path.basename(subdir), "merge"
)
is_there_basename = os.path.join(
subdir, os.path.basename(subdir)
)
if os.path.exists(up_to_merge):
if not any(
fname.upper().endswith(".PDF")
for fname in os.listdir(up_to_merge)
):
if not any(
fname.upper().endswith(".PDF")
for fname in os.listdir(is_there_basename)
):
pdfs_to_name, count, left_to_name = add_to_counter(
count, pdfs_to_name, subdir, left_to_name
)
elif os.path.exists(is_there_basename):
if not any(
fname.upper().endswith(".PDF")
for fname in os.listdir(is_there_basename)
):
pdfs_to_name, count, left_to_name = add_to_counter(
count, pdfs_to_name, subdir, left_to_name
)
else:
pdfs_to_name, count, left_to_name = add_to_counter(
count, pdfs_to_name, subdir, left_to_name
)
print(f"Pozostało {count} operatów, {pdfs_to_name} pdfów do nazwania.")
if count or pdfs_to_name != 0:
print("Pokazać listę folderów? t/n\n> ", end="")
show_folders = msvcrt.getwche().lower()
print()
if show_folders == "t":
for name in natsorted(left_to_name):
print(name)
print("\nPowtórzyć? t/n\n> ", end="")
again = msvcrt.getwche().lower()
print()
def sort(self, *, key: Optional[Callable[[Chapter], Any]] = None, reverse: bool = False):
"""Sort the ChapterList. This uses a natural sorting algorithm to sort the chapters.
:param key: An optional key if you want to override the sorting key used by the class.
:type key: Callable[[Chapter], Any]
:param reverse: Whether or not to reverse the list.
:type reverse: bool
"""
super().sort(key=key or natsort_keygen(key=lambda chapter: chapter.name), reverse=reverse)
def group_invitations(invitations, key_name, unknown='Unknown'):
key = lambda i: i[key_name] or unknown
invitations.sort(key=natsort.natsort_keygen(key, alg=natsort.IGNORECASE))
groups = []
for key, group in itertools.groupby(invitations, key):
groups.append({'label': key, 'count': len(list(group))})
return groups
def test_natsort_keygen_splits_input_with_locale():
load_locale("en_US")
strxfrm = get_strxfrm()
with patch("natsort.compat.locale.dumb_sort", return_value=False):
assert natsort_keygen(alg=ns.L)(INPUT) == (
(null_string, 6, strxfrm("A-"), 5, strxfrm("."), 34, strxfrm("e+"), 1),
(strxfrm("/Folder ("), 1, strxfrm(")/Foo")),
(null_string, 56.7),
)
with patch("natsort.compat.locale.dumb_sort", return_value=True):
assert natsort_keygen(alg=ns.L)(INPUT) == (
(null_string, 6, strxfrm("aa--"), 5, strxfrm(".."), 34, strxfrm("eE++"), 1),
(strxfrm("//ffoOlLdDeErR (("), 1, strxfrm("))//ffoOoO")),
(null_string, 56.7),
)
if PY_VERSION >= 3:
assert natsort_keygen(alg=ns.LA)(b"6A-5.034e+1") == (b"6A-5.034e+1",)
locale.setlocale(locale.LC_ALL, str(""))
def read_zip_names(input_path, filename):
# Read in file names
myzip = zipfile.ZipFile(input_path + filename, 'r')
onlyfiles = myzip.namelist()
natsort_key1 = natsort_keygen(key = lambda y: y.lower()) # natural sorting order
onlyfiles.sort(key = natsort_key1)
counter = list(range(len(onlyfiles))) # create a counter, so can randomize it
return myzip, onlyfiles, counter
def Get_versions(arch='x86'):
installed_versions = os.listdir(Variables.playonlinux_rep + "/wine/" +
Variables.os_name + "-" + arch + "/")
installed_versions.sort(key=natsort.natsort_keygen())
installed_versions.reverse()
try:
installed_versions.remove("installed")
except:
pass
return installed_versions
def test_natsort_keygen_returns_key_that_can_be_used_to_sort_list_in_place_with_same_result_as_natsorted():
a = ['a50', 'a51.', 'a50.31', 'a50.4', 'a5.034e1', 'a50.300']
b = a[:]
a.sort(key=natsort_keygen(alg=ns.F))
assert a == natsorted(b, alg=ns.F)
def test_natsort_keygen_returns_natsort_key_with_alg_option():
a = 'a-5.034e1'
assert natsort_keygen()(a) == _natsort_key(a, None, ns.I)
assert natsort_keygen(alg=ns.F | ns.S)(a) == _natsort_key(a, None, ns.F | ns.S)
def test_natsort_keygen_with_invalid_alg_input_raises_ValueError():
# Invalid arguments give the correct response
with raises(ValueError) as err:
natsort_keygen(None, "1")
assert str(err.value) == "natsort_keygen: 'alg' argument must be from the enum 'ns', got 1"
def test_natsort_keygen_returns_natsort_key_that_parses_input():
a = "a-5.034e1"
assert natsort_keygen()(a) == ("a-", 5, ".", 34, "e", 1)
assert natsort_keygen(alg=ns.F | ns.S)(a) == ("a", -50.34)
def test_natsort_keygen_splits_input_with_defaults():
assert natsort_keygen()(INPUT) == (("", 6, "A-", 5, ".", 34, "e+", 1), ("/Folder (", 1, ")/Foo"), ("", 56.7))
if PY_VERSION >= 3:
assert natsort_keygen()(b"6A-5.034e+1") == (b"6A-5.034e+1",)
def get_cover_sorter():
# Munge up the covers so they sort properly
sorter = natsort_keygen(key=lambda x: str(x.description).replace('〈', '').replace('〉', ''))
return sorter
from natsort import natsort_keygen, ns
from natsort.compat.py23 import py23_range
import locale
locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')
# Samples to parse
number = 14695498
int_string = '43493'
float_string = '-434.93e7'
plain_string = 'hello world'
fancy_string = '7abba9342fdab'
a_path = '/p/Folder (1)/file (1).tar.gz'
some_bytes = b'these are bytes'
a_list = ['hello', 'goodbye', '74']
basic_key = natsort_keygen()
real_key = natsort_keygen(alg=ns.REAL)
path_key = natsort_keygen(alg=ns.PATH)
locale_key = natsort_keygen(alg=ns.LOCALE)
def prof_time_to_generate():
print('*** Generate Plain Key ***')
for _ in py23_range(100000):
natsort_keygen()
cProfile.run('prof_time_to_generate()', sort='time')
def prof_parsing(a, msg, key=basic_key):
print(msg)
for _ in py23_range(100000):
def test_natsort_keygen_splits_input_with_real():
assert natsort_keygen(alg=ns.R)(INPUT) == (("", 6.0, "A", -50.34), ("/Folder (", 1.0, ")/Foo"), ("", 56.7))
if PY_VERSION >= 3:
assert natsort_keygen(alg=ns.R)(b"6A-5.034e+1") == (b"6A-5.034e+1",)
def prof_time_to_generate():
print('*** Generate Plain Key ***')
for _ in py23_range(100000):
natsort_keygen()
import matplotlib.pyplot as plt
import matplotlib.animation as animation
import numpy as np
import glob
import os
import time
from natsort import natsorted, natsort_keygen, ns #Librerias extra!
'''
Para graficar la evolucion de una ejecucion
'''
ANIMACION = True
files = glob.glob( "./evolucion/*fun.txt")
files.sort(key = natsort_keygen(key= lambda e : e, alg=ns.U|ns.N|ns.IC)) #Ordeno orden natural segun archivos,
figure = plt.figure()
axes = figure.add_subplot(111)
grafica = None
texto = None
if ANIMACION:
pause = False
def onClick(event):
global pause
pause ^= True
figure.canvas.mpl_connect('button_press_event', onClick)
def __lt__(self, other):
key = natsort.natsort_keygen()
return key(self.file_name) < key(other.file_name)
import errno
import os
import sqlite3
import functools
import random
import hashlib
import operator
import ntpath
import appdirs
import polytaxis
import natsort
verbose = False
_natkey = natsort.natsort_keygen()
def os_path_split_asunder(path, windows):
# Thanks http://stackoverflow.com/questions/4579908/cross-platform-splitting-of-path-in-python/4580931#4580931
# Mod for windows paths on linux
parts = []
while True:
newpath, tail = (ntpath.split if windows else os.path.split)(path)
if newpath == path:
assert not tail
if path: parts.append(path)
break
parts.append(tail)
path = newpath
parts.reverse()
