PK MZrH H flake8_tabs.py"""
Tab indentation style checker for flake8
"""
__version__ = "1.0.1"
import collections
import re
import tokenize
import flake8.checker
import flake8.processor
from flake8.processor import NEWLINE, count_parentheses
# List of keywords in Python as of Python 3.7.2rc1
# See: https://docs.python.org/3/reference/lexical_analysis.html#keywords (update as needed)
KEYWORDS = frozenset({
'False', 'await', 'else', 'import', 'pass', 'None', 'break', 'except', 'in', 'raise',
'True', 'class', 'finally', 'is', 'return', 'and', 'continue', 'for', 'lambda', 'try',
'as', 'def', 'from', 'nonlocal', 'while', 'assert', 'del', 'global', 'not', 'with',
'async', 'elif', 'if', 'or', 'yield'
})
# List of keywords that start a new definition (function or class)
KEYWORDS_DEFINITION = frozenset({'async', 'def', 'class'})
NEWLINE_CLOSE = NEWLINE | {tokenize.OP}
class Indent(collections.namedtuple("Indent", ("tabs", "spaces"))):
"""
Convience class representing the combined indentation of tabs and spaces with vector-style math
"""
def __pos__(self):
return self
def __neg__(self):
return Indent(-self.tabs, -self.spaces)
def __add__(self, other):
return Indent(self.tabs + other[0], self.spaces + other[1])
def __sub__(self, other):
return Indent(self.tabs - other[0], self.spaces - other[1])
def __mul__(self, other):
return Indent(self.tabs * other[0], self.spaces * other[1])
def __div__(self, other):
return Indent(self.tabs / other[0], self.spaces / other[1])
Indent.null = Indent(0, 0)
class FileChecker(flake8.checker.FileChecker):
"""
Blacklist some `pycodestyle` checks that our plugin will implement instead
"""
BLACKLIST = frozenset({
# E101 indentation contains mixed spaces and tabs
# – Incorrectly reports cases of using tabs for indentation but spaces for alignment
# (We have our own checks for cases where the two are mixed, which is still an error.)
"pycodestyle.tabs_or_spaces",
# E121 continuation line under-indented for hanging indent
# E122 continuation line missing indentation or outdented
# E123 closing bracket does not match indentation of opening bracket’s line
# E126 continuation line over-indented for hanging indent
# E127 continuation line over-indented for visual indent
# E128 continuation line under-indented for visual indent
# – We handle these ourselves: That's what this checker is about after all
# E124 closing bracket does not match visual indentation
# E125 continuation line with same indent as next logical line
# E129 visually indented line with same indent as next logical line
# E131 continuation line unaligned for hanging indent
# E133 closing bracket is missing indentation
# – These aren't handled yet but cannot be disabled separately
"pycodestyle.continued_indentation",
# W191 indentation contains tabs
# – Not applicable since we love tabs 🙂️
"pycodestyle.tabs_obsolete",
# W291 trailing whitespace
# W293 blank line contains whitespace
# – Implemented by `BlankLinesChecker` with more options and saner defaults
"pycodestyle.trailing_whitespace",
})
def __init__(self, filename, checks, options):
for checks_type in checks:
checks[checks_type] = list(filter(
lambda c: c["name"] not in self.BLACKLIST,
checks[checks_type]
))
super().__init__(filename, checks, options)
def expand_indent(line):
r"""Return the amount of indentation (patched function for `flake8`)
Tabs are expanded to the next multiple of the current tab size.
>>> expand_indent(' ')
4
>>> expand_indent('\t')
4
>>> expand_indent(' \t')
4
>>> expand_indent(' \t')
8
"""
if "\t" not in line:
return len(line) - len(line.lstrip())
result = 0
for char in line:
if char == "\t":
result = result // IndentationChecker.TAB_WIDTH * IndentationChecker.TAB_WIDTH
result += IndentationChecker.TAB_WIDTH
elif char == " ":
result += 1
else:
break
return result
def patch_flake8():
flake8.checker.FileChecker = FileChecker
flake8.processor.expand_indent = expand_indent
class BlankLinesChecker:
"""
Checks indentation in blank lines to match the next line if there happens to be any
"""
name = "flake8-tabs"
version = __version__
REGEXP = re.compile(r"([ \t\v]*).*?([ \t\v]*)([\r\x0C]*\n?)$")
DEFAULT_MODE = "maybe"
MODE = DEFAULT_MODE
@classmethod
def add_options(cls, option_manager):
pass
# Indentation style options
MODE_CHOICES = ("maybe", "always", "never")
option_manager.add_option(
"--blank-lines-indent", type="choice", choices=MODE_CHOICES, metavar="MODE",
default=cls.DEFAULT_MODE, parse_from_config=True,
help=("Whether there should be, properly aligned, indentation in blank lines; "
"\"always\" forces this, \"never\" disallows this (Default: %default)")
)
@classmethod
def parse_options(cls, option_manager, options, extra_args):
cls.MODE = options.blank_lines_indent
def __new__(cls, physical_line, lines, line_number):
indent, trailing, crlf = cls.REGEXP.match(physical_line).groups()
if len(physical_line) - len(crlf) < 1: # Totally blank line
if cls.MODE != "always":
return # Otherwise check whether the next non-blank line is also unindented
elif len(indent) + len(crlf) == len(physical_line):
if cls.MODE == "never": # Cannot have indented blank line in this mode
return (0, "W293 (flake8-tabs) blank line contains whitespace")
else:
# Not a blank line with whitespace
if len(trailing) > 0:
return (
len(physical_line) - len(trailing) - len(crlf),
"W291 (flake8-tabs) trailing whitespace"
)
return
# Scan for next non-blank line
expected_indent = ""
for idx in range(line_number, len(lines)):
line_indent, _, line_crlf = cls.REGEXP.match(lines[idx]).groups()
if len(line_indent) + len(line_crlf) != len(lines[idx]):
expected_indent = line_indent
break
# Compare the two indents
if indent != expected_indent:
return (0, "W293 (flake8-tabs) blank line contains unaligned whitespace")
def __init__(self, physical_line, lines, line_number):
pass
class IndentationChecker:
"""
Checks indentation within braces with a “tabs for indentation, spaces for alignment” kind of
mindset
"""
name = "flake8-tabs"
version = __version__
# Tab width: Used when requiring further indentation after we already have alignment
DEFAULT_TAB_WIDTH = 4
TAB_WIDTH = DEFAULT_TAB_WIDTH
# Indentation style: Can be used to restrict indentation to only alignment or indents for
# function calls or function/class definitions
DEFAULT_INDENT_STYLE_CALL = "auto" # "auto" (PEP-8) / "indent" / "align"
DEFAULT_INDENT_STYLE_DEF = "auto" # "auto" (PEP-8) / "indent" / "align"
INDENT_STYLE_CALL = DEFAULT_INDENT_STYLE_CALL
INDENT_STYLE_DEF = DEFAULT_INDENT_STYLE_DEF
# Indentation tabs: The number of tabs, when indenting, to require for the first level of
# indentation of functions calls, function/class definitions and other
# expressions
DEFAULT_INDENT_TABS_CALL = 1
DEFAULT_INDENT_TABS_DEF = 2 # PEP-8 requires indentation to be destingishable
DEFAULT_INDENT_TABS_EXPR = 1
INDENT_TABS_CALL = DEFAULT_INDENT_TABS_CALL
INDENT_TABS_DEF = DEFAULT_INDENT_TABS_DEF
INDENT_TABS_EXPR = DEFAULT_INDENT_TABS_EXPR
@classmethod
def add_options(cls, option_manager):
patch_flake8()
# Indentation style options
INDENT_STYLE_CHOICES = ("auto", "indent", "align")
option_manager.add_option(
"--indent-style-call", type="choice", choices=INDENT_STYLE_CHOICES, metavar="STYLE",
default=cls.DEFAULT_INDENT_STYLE_CALL, parse_from_config=True,
help=("Indentation style to force for function/method calls; setting this to "
"\"auto\" will auto-chose based on first line (Default: %default)")
)
option_manager.add_option(
"--indent-style-def", type="choice", choices=INDENT_STYLE_CHOICES, metavar="STYLE",
default=cls.DEFAULT_INDENT_STYLE_DEF, parse_from_config=True,
help=("Indentation style to force for class/function defintions; setting this to "
"\"auto\" will auto-chose based on first line (Default: %default)")
)
# First-indentation tabs options
option_manager.add_option(
"--indent-tabs-call", type="int", metavar="TABS",
default=cls.DEFAULT_INDENT_TABS_CALL, parse_from_config=True,
help=("Number of tabs to indent on the first level of indentation within a function/"
"method call (Default: %default)")
)
option_manager.add_option(
"--indent-tabs-def", type="int", metavar="TABS",
default=cls.DEFAULT_INDENT_TABS_DEF, parse_from_config=True,
help=("Number of tabs to indent on the first level of indentation within a class/"
"function definition (Default: %default)")
)
option_manager.add_option(
"--indent-tabs-expr", type="int", metavar="TABS",
default=cls.DEFAULT_INDENT_TABS_EXPR, parse_from_config=True,
help=("Number of tabs to indent on the first level of indentation within an "
"expression (Default: %default)")
)
# Prevent conflict with other plugins registering `--tab-width` as well
for option in option_manager.options:
if option.dest == "tab_width":
return
option_manager.add_option(
"--tab-width", type="int", metavar="n",
default=cls.DEFAULT_TAB_WIDTH, parse_from_config=True,
help="Number of spaces per tab character for line length checking (Default: %default)",
)
@classmethod
def parse_options(cls, option_manager, options, extra_args):
cls.INDENT_STYLE_CALL = options.indent_style_call
cls.INDENT_STYLE_DEF = options.indent_style_def
cls.INDENT_TABS_CALL = options.indent_tabs_call
cls.INDENT_TABS_DEF = options.indent_tabs_def
cls.INDENT_TABS_EXPR = options.indent_tabs_expr
cls.TAB_WIDTH = options.tab_width
@classmethod
def _parse_line_indent(cls, line):
"""
Count number of tabs at start of line followed by number of spaces at start of line
"""
tabs = 0
spaces = 0
expect_tab = True
for char in line:
if expect_tab and char == '\t':
tabs += 1
elif expect_tab and char == ' ':
spaces += 1
expect_tab = False
elif not expect_tab and char == ' ':
spaces += 1
elif not expect_tab and char == '\t':
raise ValueError("Mixed tabs and spaces in indentation")
else:
break
return Indent(tabs, spaces)
@classmethod
def _group_tokens_by_physical_line(cls, tokens):
idx_last = len(tokens) - 1
current = []
for idx, token in enumerate(tokens):
current.append(token)
if idx >= idx_last or token.end[0] < tokens[idx + 1].start[0]:
yield tuple(current)
current.clear()
def __init__(self, logical_line, indent_char, line_number, noqa, tokens):
self.messages = []
# We only care about tab indented lines
# (However there should only be minimal change required for supporting space
# indents as well!)
if indent_char != '\t' or len(tokens) < 1 or noqa:
return
# Detect which general category the given set of tokens belongs to
tokens = list(tokens)
# Assume first line to be correctly indented
try:
first_indent = current_indent = self._parse_line_indent(tokens[0].line)
except ValueError: # mixed tabs and spaces – report error and abort this logical line
self.messages.append((
tokens[0].start,
"E101 (flake8-tabs) indentation contains mixed spaces and tabs"
))
return
# Category stack: Keeps track which indentation style we should expect at this level
category_stack = ["expression"]
next_category = "expression"
# Identation stack: Keeps track of the indentation `(tabs, spaces)` caused by each brace
indent_stack = [current_indent]
prev_braces_count = 0
for token_set in self._group_tokens_by_physical_line(tokens):
assert len(token_set) >= 1
try:
line_indent = self._parse_line_indent(token_set[0].line)
except ValueError: # mixed tabs and spaces – report error and abort this logical line
self.messages.append((
tokens[0].start,
"E101 (flake8-tabs) indentation contains mixed spaces and tabs"
))
return
# Count parantheses and detect the category (definition, function call or expression)
# that we're currently in
braces_count = prev_braces_count
brace_offset = 0
brace_at_end = False
braces_closing_at_start = True
braces_closed_indent_start = Indent.null
braces_closed_indent_total = Indent.null
for token in token_set:
if token.type in NEWLINE:
continue
brace_at_end = False
if token.type == tokenize.OP:
last_braces_count = braces_count
braces_count = count_parentheses(braces_count, token.string)
if last_braces_count < braces_count:
braces_closing_at_start = False
# Opening parathese: Push latest expected category on stack
category_stack.append(next_category)
# Since this parenthesis has not caused any indent yet, push dummy value
indent_stack.append(Indent.null)
# Only offset of the last brace will survive, telling us how many spaces
# to add should we chose alignment
brace_offset = token.end[1] - line_indent.tabs - line_indent.spaces
# This will be overwritten if the last token in the line wasn't an
# opening parenthese
brace_at_end = True
elif last_braces_count > braces_count:
# Closing parathese: Remove last category from stack
category_stack.pop()
indent_popped = indent_stack.pop()
# Add up all the removed indentation thanks to closing parenthesis
# (Remember that most will be `(0, 0)`.)
braces_closed_indent_total += indent_popped
# Add up all the removed indentation that happened before any other
# indentation to find the proper level of outdenting
if braces_closing_at_start:
braces_closed_indent_start += indent_popped
else:
braces_closing_at_start = False
elif token.type == tokenize.NAME:
braces_closing_at_start = False
if token.string in KEYWORDS_DEFINITION:
# Definition keyword for class or function
# (If it's not a definition it'd have be a syntax error.)
next_category = "definition"
continue
elif token.string not in KEYWORDS and next_category != "definition":
# Non-keyword name not preceeded by definition: Probably a function call
next_category = "call"
continue
elif token.string not in KEYWORDS:
continue
elif token.type not in NEWLINE:
braces_closing_at_start = False
# Catch-all for cases other than the two above
next_category = "expression"
assert braces_count == len(category_stack) - 1
category = category_stack[-1]
# Choose expected indentation style for the following lines based on the innermost
# active category
indent_style = "indent"
indent_tabs = self.INDENT_TABS_EXPR
if category == "call":
indent_style = self.INDENT_STYLE_CALL
indent_tabs = self.INDENT_TABS_CALL
elif category == "definition":
indent_style = self.INDENT_STYLE_DEF
indent_tabs = self.INDENT_TABS_DEF
if indent_style not in ("indent", "align"):
# Auto-choose style based on what next line uses (PEP-8)
indent_style = "align" if not brace_at_end else "indent"
# Calculate new expected indentation (both for this and the following lines)
current_indent_delta = Indent.null
if braces_count > prev_braces_count:
if indent_style == "indent":
# Expect one extra level of indentation for each line that left some braces
# open in the following lines, except for the first level which has a
# configurable increase per type
tabs = indent_tabs if prev_braces_count == 0 else 1
# Do not increase number of tabs after having added spaces for any reason
if current_indent.spaces - braces_closed_indent_total.spaces > 0:
current_indent_delta += (0, tabs * self.TAB_WIDTH)
else:
current_indent_delta += (tabs, 0)
else: # indent_style == "align"
current_indent_delta += (0, brace_offset)
# Update indent stack entry to attach the diff from above to the last opened brace
indent_stack[-1] = indent_stack[-1] + current_indent_delta
# Apply indentation changes caused by closed braces
current_indent_delta -= braces_closed_indent_total
# Expect the closing braces to be on the new level already if it is the first
# content on the this line
if braces_count < prev_braces_count:
current_indent -= braces_closed_indent_start
current_indent_delta += braces_closed_indent_start
# Compare settings on current line
if line_indent != current_indent:
# Find error code similar to `pycodestyle`
code = 112
if line_indent == first_indent:
code = 122
elif current_indent.spaces == line_indent.spaces == 0:
if line_indent.tabs < current_indent.tabs:
code = 121
else:
code = 126
else:
if line_indent.spaces > current_indent.spaces:
code = 127
else:
code = 128
code_text = "E{0} (flake8-tabs)".format(code)
# Generate and store error message
if current_indent.spaces == line_indent.spaces:
self.messages.append((
token_set[0].start,
"{0} unexpected number of tabs within {1} "
"(expected {2.tabs}, got {3.tabs})".format(
code_text, category, current_indent, line_indent
)
))
elif current_indent.tabs == line_indent.tabs:
self.messages.append((
token_set[0].start,
"{0} unexpected number of spaces within {1} "
"(expected {2.spaces}, got {3.spaces})".format(
code_text, category, current_indent, line_indent
)
))
else:
self.messages.append((
token_set[0].start,
"{0} unexpected number of tabs and spaces within {1} "
"(expected {2.tabs} tabs and {2.spaces} spaces, "
"got {3.tabs} tabs and {3.spaces} spaces)".format(
code_text, category, current_indent, line_indent,
)
))
# Apply deltas
current_indent += current_indent_delta
assert sum(indent_stack, Indent.null) == current_indent
# Remember stuff for next iteration
prev_braces_count = braces_count
# All parentheses that were opened must have been closed again
assert prev_braces_count == 0
def __iter__(self):
return iter(self.messages)
PK !HcL s , flake8_tabs-1.0.1.dist-info/entry_points.txtNINK(I+ϋ*IL*KIK-([9}@٩Ey)y%%@P{"a PK
J>K1 & flake8_tabs-1.0.1.dist-info/LICENSE.md### GNU LESSER GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc.
Everyone is permitted to copy and distribute verbatim copies of this
license document, but changing it is not allowed.
This version of the GNU Lesser General Public License incorporates the
terms and conditions of version 3 of the GNU General Public License,
supplemented by the additional permissions listed below.
#### 0. Additional Definitions.
As used herein, "this License" refers to version 3 of the GNU Lesser
General Public License, and the "GNU GPL" refers to version 3 of the
GNU General Public License.
"The Library" refers to a covered work governed by this License, other
than an Application or a Combined Work as defined below.
An "Application" is any work that makes use of an interface provided
by the Library, but which is not otherwise based on the Library.
Defining a subclass of a class defined by the Library is deemed a mode
of using an interface provided by the Library.
A "Combined Work" is a work produced by combining or linking an
Application with the Library. The particular version of the Library
with which the Combined Work was made is also called the "Linked
Version".
The "Minimal Corresponding Source" for a Combined Work means the
Corresponding Source for the Combined Work, excluding any source code
for portions of the Combined Work that, considered in isolation, are
based on the Application, and not on the Linked Version.
The "Corresponding Application Code" for a Combined Work means the
object code and/or source code for the Application, including any data
and utility programs needed for reproducing the Combined Work from the
Application, but excluding the System Libraries of the Combined Work.
#### 1. Exception to Section 3 of the GNU GPL.
You may convey a covered work under sections 3 and 4 of this License
without being bound by section 3 of the GNU GPL.
#### 2. Conveying Modified Versions.
If you modify a copy of the Library, and, in your modifications, a
facility refers to a function or data to be supplied by an Application
that uses the facility (other than as an argument passed when the
facility is invoked), then you may convey a copy of the modified
version:
- a) under this License, provided that you make a good faith effort
to ensure that, in the event an Application does not supply the
function or data, the facility still operates, and performs
whatever part of its purpose remains meaningful, or
- b) under the GNU GPL, with none of the additional permissions of
this License applicable to that copy.
#### 3. Object Code Incorporating Material from Library Header Files.
The object code form of an Application may incorporate material from a
header file that is part of the Library. You may convey such object
code under terms of your choice, provided that, if the incorporated
material is not limited to numerical parameters, data structure
layouts and accessors, or small macros, inline functions and templates
(ten or fewer lines in length), you do both of the following:
- a) Give prominent notice with each copy of the object code that
the Library is used in it and that the Library and its use are
covered by this License.
- b) Accompany the object code with a copy of the GNU GPL and this
license document.
#### 4. Combined Works.
You may convey a Combined Work under terms of your choice that, taken
together, effectively do not restrict modification of the portions of
the Library contained in the Combined Work and reverse engineering for
debugging such modifications, if you also do each of the following:
- a) Give prominent notice with each copy of the Combined Work that
the Library is used in it and that the Library and its use are
covered by this License.
- b) Accompany the Combined Work with a copy of the GNU GPL and this
license document.
- c) For a Combined Work that displays copyright notices during
execution, include the copyright notice for the Library among
these notices, as well as a reference directing the user to the
copies of the GNU GPL and this license document.
- d) Do one of the following:
- 0) Convey the Minimal Corresponding Source under the terms of
this License, and the Corresponding Application Code in a form
suitable for, and under terms that permit, the user to
recombine or relink the Application with a modified version of
the Linked Version to produce a modified Combined Work, in the
manner specified by section 6 of the GNU GPL for conveying
Corresponding Source.
- 1) Use a suitable shared library mechanism for linking with
the Library. A suitable mechanism is one that (a) uses at run
time a copy of the Library already present on the user's
computer system, and (b) will operate properly with a modified
version of the Library that is interface-compatible with the
Linked Version.
- e) Provide Installation Information, but only if you would
otherwise be required to provide such information under section 6
of the GNU GPL, and only to the extent that such information is
necessary to install and execute a modified version of the
Combined Work produced by recombining or relinking the Application
with a modified version of the Linked Version. (If you use option
4d0, the Installation Information must accompany the Minimal
Corresponding Source and Corresponding Application Code. If you
use option 4d1, you must provide the Installation Information in
the manner specified by section 6 of the GNU GPL for conveying
Corresponding Source.)
#### 5. Combined Libraries.
You may place library facilities that are a work based on the Library
side by side in a single library together with other library
facilities that are not Applications and are not covered by this
License, and convey such a combined library under terms of your
choice, if you do both of the following:
- a) Accompany the combined library with a copy of the same work
based on the Library, uncombined with any other library
facilities, conveyed under the terms of this License.
- b) Give prominent notice with the combined library that part of it
is a work based on the Library, and explaining where to find the
accompanying uncombined form of the same work.
#### 6. Revised Versions of the GNU Lesser General Public License.
The Free Software Foundation may publish revised and/or new versions
of the GNU Lesser General Public License from time to time. Such new
versions will be similar in spirit to the present version, but may
differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Library
as you received it specifies that a certain numbered version of the
GNU Lesser General Public License "or any later version" applies to
it, you have the option of following the terms and conditions either
of that published version or of any later version published by the
Free Software Foundation. If the Library as you received it does not
specify a version number of the GNU Lesser General Public License, you
may choose any version of the GNU Lesser General Public License ever
published by the Free Software Foundation.
If the Library as you received it specifies that a proxy can decide
whether future versions of the GNU Lesser General Public License shall
apply, that proxy's public statement of acceptance of any version is
permanent authorization for you to choose that version for the
Library.
PK !H>*R Q ! flake8_tabs-1.0.1.dist-info/WHEEL HM
K-*ϳR03rOK-J,/RH,rzd&Y)r$[)T&Ur PK !H ?u
P $ flake8_tabs-1.0.1.dist-info/METADATAYr.#]DdI*aGiYq4%Œd: bS>E{W'w.Eq&m) |`R*VAt {{LM@uv 5tz.T勁RCiX*\bhMtts9y"Sr'E";MԤ_ݺSaًg,&6 D+e4IT> OzL2j
L 7ɵ^,p{"i&#G6-NjAw]zy*
+> _'$&ֱ<,cHӾgz!ay
, m~"3B/Oav-Zj:չJE9LLT %2[vN_l5_v Ǧ& SKddx}Ve3K;**
0WѮ&奍DeS,ses ` W%L3W0yf\, ?vo%+yp me6:*ׯN/U:?v
r$ifb;&
Km B5WmKҽӒ9 yjbr>eJ% hp'l&DK5,"znt/rbgnk\i
ݑ#
ˡ Edam>SՎ bqrOKpfEj7oԮÅHI!s$[ITٮYRM*U MRw4"zSXEӮ-BbhkNnl~2ith5M-=PTG&X$7YTEpod !'_,QaJxk
'A7jy60S,OtO!Ibf\Gzx ?Sf
\Z9,1:%p49z72* bLm= zĿ&#%cqMldFQIO^$ZTrJ3"D`,F^KkGeL@ٖ_],.Nqbաǻg=ySk E;D 继'Ggǽiܪ5)Mȱ98#ȈF5
(Ẕui=G4BcM P-1NR3\fUYM Y$cLbNDXoj7V) /n#_~ uR|i)E5?sBH lO(2 DgPo VDM݁]{ >?ßOaɪ&"@)r<:}y3vn#3ƀ i5cz_Rlh+o C9 ?"_կt^i(Le; Z`y,[s
U$ ȸd6d*B"h){C-*abUݎYW /D # yZ۠l&'_'t=sQ+ff!5ٗ 0'$S Tρ<̍k=D$ؽt Dh?t2 O[ VSaZ.' 5O S1a+Ȃߌ<x<7 r=3j:ݓU8$*],mPC\6g~>~愸4נxYPE)q["bݹHu*H6}?
u [>={4GU;-N+r/pzN S @ߡ_Έ+vG*J-z!=6
I9>⫢#a̺M訄>Icc.?n^bȿ@r BPB3F ,-C,,/z8z7 4f#>(
VXdjx:W,|d :迓v,fX9ErcEh:-_m!/&0E`0SS s+k/q+BLUkO{MyZD0u8ۢ=<֩ýil@yF·&~8ofxI`V7mj:X-9]M@P BXv:4y+Aª(nD,X PK !Hn*/ " flake8_tabs-1.0.1.dist-info/RECORD}9v@ aHA 8PAYx+|b@[K#h !ߦ=%96qǫxqyH("VX%R4(k:++.I3u@ܘ[±BĔGa\9`4 +NG*S !x{Y=^Tf}Wۚ; iX Lnwu1@;;Ug0Hrs3Dɟq]ٙ٭ }dI.%ELX$U@T!wE\ U` "nR XPK MZrH H flake8_tabs.pyPK !HcL s , 1H flake8_tabs-1.0.1.dist-info/entry_points.txtPK
J>K1 & H flake8_tabs-1.0.1.dist-info/LICENSE.mdPK !H>*R Q ! f flake8_tabs-1.0.1.dist-info/WHEELPK !H ?u
P $ vg flake8_tabs-1.0.1.dist-info/METADATAPK !Hn*/ " er flake8_tabs-1.0.1.dist-info/RECORDPK s