blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 2 616 | content_id stringlengths 40 40 | detected_licenses listlengths 0 69 | license_type stringclasses 2
values | repo_name stringlengths 5 118 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringlengths 4 63 | visit_date timestamp[us] | revision_date timestamp[us] | committer_date timestamp[us] | github_id int64 2.91k 686M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 23
values | gha_event_created_at timestamp[us] | gha_created_at timestamp[us] | gha_language stringclasses 220
values | src_encoding stringclasses 30
values | language stringclasses 1
value | is_vendor bool 2
classes | is_generated bool 2
classes | length_bytes int64 2 10.3M | extension stringclasses 257
values | content stringlengths 2 10.3M | authors listlengths 1 1 | author_id stringlengths 0 212 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
ac4b87c2ef8d46c4149984f849a04f5e20b3fc0e | 600df3590cce1fe49b9a96e9ca5b5242884a2a70 | /third_party/catapult/telemetry/telemetry/timeline/sample.py | 806f60fafa2635a581485698ceee0eed38121471 | [
"LGPL-2.0-or-later",
"GPL-1.0-or-later",
"MIT",
"Apache-2.0",
"BSD-3-Clause"
] | permissive | metux/chromium-suckless | efd087ba4f4070a6caac5bfbfb0f7a4e2f3c438a | 72a05af97787001756bae2511b7985e61498c965 | refs/heads/orig | 2022-12-04T23:53:58.681218 | 2017-04-30T10:59:06 | 2017-04-30T23:35:58 | 89,884,931 | 5 | 3 | BSD-3-Clause | 2022-11-23T20:52:53 | 2017-05-01T00:09:08 | null | UTF-8 | Python | false | false | 713 | py | # Copyright 2014 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import telemetry.timeline.event as timeline_event
class Sample(timeline_event.TimelineEvent):
"""A Sample represents a sample taken at an instant in time
plus parameters associated with that sample.
NOTE: The Sample class implements the same interface as
Slice. These must be kept in sync.
All time units are stored in milliseconds.
"""
def __init__(self, parent_thread, category, name, timestamp, args=None):
super(Sample, self).__init__(
category, name, timestamp, 0, args=args)
self.parent_thread = parent_thread
| [
"enrico.weigelt@gr13.net"
] | enrico.weigelt@gr13.net |
e2ead4671cce3be455a5a6e25ee01ecbcd94bbbd | e41cab4287e100afda2050e5ac3e07ce04b135a2 | /sasoptpy/libs/numpy.py | 931c27e9607e640ad9cb32ec458b47ca67f87251 | [
"LicenseRef-scancode-unknown-license-reference",
"Apache-2.0"
] | permissive | yanxu55/sasoptpy | a8f60caa6bab0883013cf319f23c030f3284cfda | 5f2ea28bb66cf072527b8787ad6c7bd516db5d00 | refs/heads/master | 2023-01-05T09:05:54.988131 | 2022-03-01T18:01:39 | 2022-03-01T18:01:39 | 156,903,392 | 1 | 0 | Apache-2.0 | 2018-11-09T18:38:38 | 2018-11-09T18:38:38 | null | UTF-8 | Python | false | false | 159 | py |
import numpy as np
number = np.number
isinstance = np.issubdtype
issubdtype = np.issubdtype
ndarray = np.ndarray
nan = np.nan
inf = np.inf
isnan = np.isnan
| [
"sertalp.cay@sas.com"
] | sertalp.cay@sas.com |
e380684efa4489a420250c6592f1d2fbbe93c88d | 61733b45d5efb7e1b5c76fcf795be28ccbe9d350 | /C04_Feature_Mapping.py | 8cc873d68a251e2e1382e0ce825f1e63f2e96f06 | [] | no_license | Shyam-Khokhariya/ML-Python | 9b837616623bdc011059ad69e468c3fc2c6cf57c | 13fb1d27b68efdf32b4b8ae6c735149cb37a52c7 | refs/heads/master | 2020-04-09T02:01:08.393345 | 2019-05-31T13:37:20 | 2019-05-31T13:37:20 | 159,925,858 | 2 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,204 | py | import pandas as pd
import numpy as np
df=pd.DataFrame([
['Green',10.0,'M','Class1'],
['Blue',15,'S','Class2'],
['Yellow',14.5,'XL','Class3'],
['Pink',12.2,'L','Class4']
])
df.columns=('Color','Price','Size','ClassLable')
# print(df)
size_mapping={
'M':2,
'S':1,
'L':3,
'XL':4
}
df['Size']=df['Size'].map(size_mapping)
# inv_mapping={v:k for k,v in size_mapping.items()}
# df['Size']=df['Size'].map(inv_mapping)
# print(df)
class_mapping={lable:index for index,lable in enumerate(np.unique(df['ClassLable']))}
df['ClassLable']=df['ClassLable'].map(class_mapping)
inv_class={v:k for k,v in class_mapping.items()}
df['ClassLable']=df['ClassLable'].map(inv_class)
# print(df)
from sklearn.preprocessing import LabelEncoder
class_LE=LabelEncoder()
y=class_LE.fit_transform(df['ClassLable'].values)
y1=class_LE.inverse_transform(y)
# print(y)
# print(y1)
X=df[['Color','Size','Price']].values
color_LE=LabelEncoder()
X[:,0]=color_LE.fit_transform(X[:,0])
print(X)
from sklearn.preprocessing import OneHotEncoder
ohe=OneHotEncoder(categorical_features=[0])
p=ohe.fit_transform(X).toarray()
print(p)
print(pd.get_dummies(df[['Price','Color','Size']],drop_first=True)) | [
"noreply@github.com"
] | Shyam-Khokhariya.noreply@github.com |
a0d9c35a415b9dd7d28d35a0995ae5dc81209c6a | 4dd1d8fa59e20061e2c12e540fc52b1b305e575b | /source/sims/s89/plt-exact-sol.py | 0d82396776954a630e3f77a1be11e7c2991767ef | [
"MIT"
] | permissive | ammarhakim/ammar-simjournal | f63521906a97d55ab290a5960d94758139944c89 | 5019f4723e20db80a20db6f2bd454c2fd3241412 | refs/heads/master | 2023-06-08T08:18:11.722779 | 2023-06-02T15:06:43 | 2023-06-02T15:06:43 | 204,050,516 | 3 | 3 | null | 2022-02-01T16:53:13 | 2019-08-23T18:28:44 | Lua | UTF-8 | Python | false | false | 765 | py | import pylab
import tables
import math
import numpy
def exactSol(a, b, X):
c0 = -(1/2.0 + a/12.0 + b/30.0)
c1 = 0.0
return X**2/2 + a*X**4/12 + b*X**6/30 + c0*X + c1
fh = tables.openFile("s89-poisson-o3-1d_phi.h5")
q = fh.root.StructGridField
nx, nc = q.shape
Xf = pylab.linspace(0, 1, nx)
qe = q[:,0]
dx = Xf[1]-Xf[0]
Xm = pylab.linspace(0.5*dx, 1-0.5*dx, nx-1)
qm = q[:-1,1]
a = 2.0
b = -12.0
Xhr = pylab.linspace(0, 1, 101)
fhr = exactSol(a, b, Xhr)
# make plot comparing exact to numerical solution
pylab.plot(Xhr, fhr, '-r', Xf, qe, 'ok', Xm, qm, 'ok')
# compute error
fex_e = exactSol(a, b, Xf)
fex_m = exactSol(a, b, Xm)
error = (numpy.abs(fex_e-qe).sum() + numpy.abs(fex_m-qm).sum())/(nx+nx-1);
print "%g %g" % (dx, error)
pylab.show()
| [
"11265732+ammarhakim@users.noreply.github.com"
] | 11265732+ammarhakim@users.noreply.github.com |
d9fd84278cb0fd0e16b7d8b5ef572a359ea5de86 | 87f9ad9f05a2786237d7344921ffd43dfd1b42d4 | /window/version.py | e46b13db78c38bc6cb24c7db7230884871af22b6 | [] | no_license | ctfang/docker-tkinter | 852f0539efc16aea51e6183e8cf538eb7ee9e500 | e73c281c960d42044e081f2e299a1024bfeb2a44 | refs/heads/master | 2021-09-03T13:29:30.878821 | 2018-01-09T11:33:01 | 2018-01-09T11:33:01 | 116,377,109 | 2 | 0 | null | null | null | null | UTF-8 | Python | false | false | 381 | py | import tkinter as tk
class version(tk.LabelFrame):
title = "版本说明"
version = "版本：RC0.0.1\n作者：明月有色\n版权所有：blog.ctfang.com\n源码地址：github.com/selden1992"
def __init__(self, master=None, **kw):
super().__init__(master, kw)
text = tk.Text(self)
text.insert(tk.INSERT,self.version)
text.pack() | [
"baichou@qingmutec.com"
] | baichou@qingmutec.com |
d093c6aa8d43507079830298c8ea4c5e6dc134fc | 4aa9fb335009ee76319c297ecc96e3a6e55f4f18 | /blog/admin.py | 166543321585e05bd9d3194a3c73b3f2069b12cb | [] | no_license | yemingrujing/blogproject | d041c0051792b2ac18f2c2910b6f10431610bd84 | 751890408afe1279d411ad112ccdebd51fb515f6 | refs/heads/master | 2020-07-03T23:38:33.313856 | 2019-09-05T07:12:10 | 2019-09-05T07:12:10 | 202,087,752 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 835 | py | from django.contrib import admin
from .models import Post, Category, Tag
# Register your models here.
@admin.register(Post)
class PostAdmin(admin.ModelAdmin):
# 自定义显示字段
list_display = ['title', 'create_time', 'modified_time', 'category', 'author']
# 每页显示条目数
list_per_page = 5
# 添加快速查询栏
search_fields = ('title', 'category__name')
# 创建过滤器
list_filter = ('create_time', 'category')
# 降序排列
ordering = ('-create_time',)
# list_editable 设置默认可编辑字段
list_editable = ['category']
# 设置哪些字段可以点击进入编辑界面
list_display_links = ('title', 'author')
admin.site.site_header = '博客后台管理'
admin.site.site_title = '登录'
admin.site.register(Category)
admin.site.register(Tag)
| [
"yemingrujing@users.noreply.github.com"
] | yemingrujing@users.noreply.github.com |
836e4a0d58db89b30890ac1c870910550a3e7b3d | a0567cb57411ea07d36b36c08a550a0c1a966642 | /printing_models.py | 2dcb4f0f7b3391d2ff42e21752ad4f69bfa3fc6d | [] | no_license | Dmitry-pytho/Education | 55ae0b12604452a793e473817acb75e37a2c68f6 | ec6446a825d9f2a698b382f481448951872c1789 | refs/heads/main | 2023-03-22T21:47:04.201095 | 2021-03-14T07:08:42 | 2021-03-14T07:08:42 | 317,008,059 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 623 | py | def print_models(unprinted_designs, completed_models):
while unprinted_designs:
current_design = unprinted_designs.pop()
print("Printing model: " + current_design)
completed_models.append(current_design)
def show_completed_models(completed_models):
print("\nThe following models have been printed:")
for completed_model in completed_models:
print(completed_model)
unprinted_designs = ["iphone case", "robot pendant", "dodecahedron"]
completed_models = []
print_models(unprinted_designs [:], completed_models)
show_completed_models(completed_models)
print(unprinted_designs) | [
"dmitry.solomiannyi@gmail.com"
] | dmitry.solomiannyi@gmail.com |
84456b2209cb17f9367d8738999a3584467581c3 | 95c79b0b95dc5dd184ce0d00390094e98ac42c3d | /DjangoApi/settings.py | b975cf2a0af08538512892d5a247d902bc8af324 | [] | no_license | FouzanJafri/DjangoApi | 15a004a47f5e828ea7ea3125e0c6e863c99fc544 | 86644bc07c23271651d9b4fc31eea2e018198481 | refs/heads/main | 2023-08-25T16:20:20.582962 | 2021-10-30T06:54:44 | 2021-10-30T06:54:44 | 422,801,471 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 3,422 | py | """
Django settings for DjangoApi project.
Generated by 'django-admin startproject' using Django 3.2.8.
For more information on this file, see
https://docs.djangoproject.com/en/3.2/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/3.2/ref/settings/
"""
from pathlib import Path
# Build paths inside the project like this: BASE_DIR / 'subdir'.
BASE_DIR = Path(__file__).resolve().parent.parent
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.2/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = 'django-insecure-0+k(a)or)3=!=ss%vqtb^ne83*9r#=!)_v8e4$=+e*w(ushvo#'
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True
ALLOWED_HOSTS = []
# Application definition
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'rest_framework',
'corsheaders',
'EmployeeApp.apps.EmployeeappConfig',
]
CORS_ORIGIN_ALLOW_ALL = True
MIDDLEWARE = [
'corsheaders.middleware.CorsMiddleware',
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
ROOT_URLCONF = 'DjangoApi.urls'
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]
WSGI_APPLICATION = 'DjangoApi.wsgi.application'
# Database
# https://docs.djangoproject.com/en/3.2/ref/settings/#databases
DATABASES = {
'default': {
'ENGINE': 'djongo',
'NAME': 'user_db',
'HOST': '127.0.0.1',
'PORT': 27017,
}
}
# Password validation
# https://docs.djangoproject.com/en/3.2/ref/settings/#auth-password-validators
AUTH_PASSWORD_VALIDATORS = [
{
'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
},
]
# Internationalization
# https://docs.djangoproject.com/en/3.2/topics/i18n/
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'
USE_I18N = True
USE_L10N = True
USE_TZ = True
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/3.2/howto/static-files/
STATIC_URL = '/static/'
# Default primary key field type
# https://docs.djangoproject.com/en/3.2/ref/settings/#default-auto-field
DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'
| [
"jafrifouzan@gmail.com"
] | jafrifouzan@gmail.com |
8b653c1e485eb97ee64ff943efc60272791eafff | eccdc5f337f97b0d12a1516518422416cb45a6e8 | /pcm2wav.py | b39c77134a2c67fff1ead71f56c4d14ae8283469 | [] | no_license | jimmy3663/Venice | 82770c4ced80e92ec48d2a71e4c893697e3a3268 | 43a1e6b4958352380584a5a9e0cb1eabfdeee80d | refs/heads/master | 2021-01-02T16:15:26.420010 | 2020-02-12T07:37:01 | 2020-02-12T07:37:01 | 239,698,903 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 567 | py | import wave
from pydub import AudioSegment
def pcm2wav( pcm_data, wav_file, channels=1, bit_depth=16, sampling_rate=44100 ):
# Check if the options are valid.
if bit_depth % 8 !=0:
raise ValueError("bit_depth "+str(bit_depth)+" must be a multiple of 8.")
# Read the .pcm file as a binary file and store the data to pcm_data
obj2write = wave.open(wav_file,'wb')
obj2write.setnchannels(channels)
obj2write.setsampwidth(bit_depth//8)
obj2write.setframerate(sampling_rate)
obj2write.writeframes(pcm_data)
obj2write.close()
| [
"jimmy3663@naver.com"
] | jimmy3663@naver.com |
c48865c2bf55d296f8ca4ba894ac477f9b557634 | 97893ca3ff69dc6e753a0e75cf68e19636c3fe39 | /meta/eda.py | fcae6e1369c5cde818773c4f03584bab8df140a5 | [] | no_license | lisatostrams/MLIP | ca443250f9199363504499bed4db7f4cd33d00f8 | 3f12e3c59e55cdeeb5a172b0f256768ab1796255 | refs/heads/master | 2020-04-22T21:07:33.630933 | 2019-02-28T11:23:06 | 2019-02-28T11:23:06 | 170,663,297 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 563 | py | # -*- coding: utf-8 -*-
"""
Created on Thu Feb 14 10:33:00 2019
@author: Lisa
"""
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
data = pd.read_csv('petfinder-adoption-prediction/train/train.csv')
#%%
import collections
name_counter = collections.Counter(data['Name'].values)
lst = name_counter.most_common(20)
df = pd.DataFrame(lst, columns = ['Name', 'Count'])
df.plot.bar(x='Name',y='Count')
#%%
adoptlst = []
for l in lst:
idx = data.loc[:, 'Name'] == l[0]
adoptlst.append(data[idx]['AdoptionSpeed'].values)
| [
"lmc.tostrams@student.ru.nl"
] | lmc.tostrams@student.ru.nl |
eb264914f5c39d64a01c1b43b256fbe0b4630d53 | e05552e5ed1b8376187530804f95e56e1ce0d4ce | /src/db/models.py | 031bf8c406b66c97456d9786a611c7e6b963d517 | [] | no_license | harshgupta6789/NLIDB | bc15c3d0ce2af5e95cf3d1bda8c049aa8fc85e52 | 03b81dae1a0d53f6fcc778eb30ddfac93ecdeeb0 | refs/heads/main | 2023-05-13T11:12:35.949304 | 2021-06-01T09:10:10 | 2021-06-01T09:10:10 | 346,608,816 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 629 | py | import os
from django.core.validators import FileExtensionValidator
from django.db import models
# Create your models here.
def content_file_name(instance, filename):
if os.path.exists("database/db.sql"):
os.remove("database/db.sql")
Database.objects.all().delete()
filename = 'db.sql'
return os.path.join('database', filename)
class Database(models.Model):
db = models.FileField(
upload_to=content_file_name,
blank=True,
help_text="Choose SQL File",
validators=[FileExtensionValidator(allowed_extensions=['sql'])])
def __str__(self):
return 'db.sql'
| [
"harshhvg999@gmail.com"
] | harshhvg999@gmail.com |
b664e2d2c02565c0ffa8a6ece9e214350803f1b4 | b109a597a6f6a3de22f069f0b865aa58b06d0095 | /maml-vae/code/models/maml_vae.py | db6e9cd0a9df190cccef6a4487257e32fa172f12 | [] | no_license | Higgsboson-X/maml-text-style-transfer | 76a344dd27e9f8ec206514c93ced87cf7d4013a2 | 8eca23eef1a35417d87b02196debb80f677740c3 | refs/heads/master | 2022-03-22T00:47:17.394700 | 2019-12-14T03:21:14 | 2019-12-14T03:21:14 | 225,415,882 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 13,437 | py | import os
import torch
import copy
import datetime as dt
import numpy as np
# ----------------
import models.vae
import utils.nn
import utils.data_processor
from config.model_config import default_maml_mconf
class MAMLAdvAutoencoder:
def __init__(self, device, num_tasks=2, init_embedding=None, mconf=default_maml_mconf):
self.num_tasks = num_tasks
self.mconf = mconf
self.m = models.vae.AdvAutoencoder(device, init_embedding, mconf)
self.device = device
def train_maml(self, support_input_sequences, support_lengths, support_labels, support_bow_representations, support_batch_size, query_input_sequences, query_lengths, query_labels, query_bow_representations, query_batch_size, epochs, init_epoch=0):
support_batch_generator, num_batches = utils.data_processor.get_maml_batch_generator(
support_input_sequences, support_lengths, support_labels,
support_bow_representations, support_batch_size, self.num_tasks, device=self.device
)
query_batch_generator, _ = utils.data_processor.get_maml_batch_generator(
query_input_sequences, query_lengths, query_labels,
query_bow_representations, query_batch_size, self.num_tasks, device=self.device
)
gamma = self.mconf.gamma_init
meta_autoencoder_optimizer = torch.optim.Adam(
params=self.m.autoencoder_params, lr=self.mconf.meta_autoencoder_lr,
betas=self.mconf.betas
)
meta_style_adversary_optimizer = torch.optim.RMSprop(
params=self.m.style_adversary_params, lr=self.mconf.meta_style_adversarial_lr
)
meta_content_adversary_optimizer = torch.optim.RMSprop(
params=self.m.content_adversary_params, lr=self.mconf.meta_content_adversarial_lr
)
meta_style_overall_optimizer = torch.optim.RMSprop(
params=self.m.style_overall_params, lr=self.mconf.meta_style_overall_lr
)
sub_autoencoder_optimizer = torch.optim.Adam(
params=self.m.autoencoder_params, lr=self.mconf.sub_autoencoder_lr,
betas=self.mconf.betas
)
sub_style_adversary_optimizer = torch.optim.RMSprop(
params=self.m.style_adversary_params, lr=self.mconf.sub_style_adversarial_lr
)
sub_content_adversary_optimizer = torch.optim.RMSprop(
params=self.m.content_adversary_params, lr=self.mconf.sub_content_adversarial_lr
)
sub_style_overall_optimizer = torch.optim.RMSprop(
params=self.m.style_overall_params, lr=self.mconf.sub_style_overall_lr
)
iterations = 0
style_kl_weight, content_kl_weight = 0., 0.
for epoch in range(init_epoch, epochs):
autoencoder_epoch_loss = 0.
adversarial_epoch_loss = 0.
style_overall_epoch_loss = 0.
init_state = copy.deepcopy(self.m.state_dict())
for b in range(num_batches):
# debug
# if b == 1:
# break
iterations += 1
support_batch = support_batch_generator.__next__()
query_batch = query_batch_generator.__next__()
if iterations < self.mconf.kl_anneal_iterations:
style_kl_weight = self.m.get_annealed_weight(iterations, self.mconf.style_kl_weight)
content_kl_weight = self.m.get_annealed_weight(iterations, self.mconf.content_kl_weight)
support_autoencoder_loss, support_adv_style_loss, support_adv_content_loss, support_style_overall_loss = [], [], [], []
query_autoencoder_loss, query_adv_style_loss, query_adv_content_loss, query_style_overall_loss = [], [], [], []
for t in range(self.num_tasks):
batch_task = [support_batch[i][t] for i in range(len(support_batch))]
self.m.load_state_dict(init_state)
sub_autoencoder_optimizer.zero_grad()
sub_style_adversary_optimizer.zero_grad()
sub_content_adversary_optimizer.zero_grad
sub_style_overall_optimizer.zero_grad()
init_state = copy.deepcopy(self.m.state_dict())
for step in range(self.mconf.num_updates):
[
reconstruction_loss,
style_kl_loss, content_kl_loss,
style_multitask_loss, content_multitask_loss,
style_adversarial_entropy, content_adversarial_entropy,
style_adversarial_loss, content_adversarial_loss,
style_overall_pred_loss
] = self.m._feed_batch(
batch_task[0], batch_task[1], batch_task[2], batch_task[3],
gamma=gamma, style_kl_weight=style_kl_weight, content_kl_weight=content_kl_weight
)
'''
if style_adversarial_loss <= self.mconf.adv_loss_tolerance and content_adversarial_loss <= self.mconf.adv_loss_tolerance:
composite_loss = reconstruction_loss + style_kl_weight * style_kl_loss + content_kl_weight * content_kl_loss \
+ self.mconf.style_multitask_loss_weight * style_multitask_loss \
+ self.mconf.content_multitask_loss_weight * content_multitask_loss \
- self.mconf.style_adv_loss_weight * style_adversarial_entropy \
- self.mconf.content_adv_loss_weight * content_adversarial_entropy
else:
composite_loss = reconstruction_loss + style_kl_weight * style_kl_loss + content_kl_weight * content_kl_loss \
+ style_multitask_loss + content_multitask_loss
'''
composite_loss = reconstruction_loss + style_kl_weight * style_kl_loss + content_kl_weight * content_kl_loss \
+ self.mconf.style_multitask_loss_weight * style_multitask_loss \
+ self.mconf.content_multitask_loss_weight * content_multitask_loss \
- self.mconf.style_adv_loss_weight * style_adversarial_entropy \
- self.mconf.content_adv_loss_weight * content_adversarial_entropy
sub_autoencoder_optimizer.zero_grad()
sub_style_adversary_optimizer.zero_grad()
sub_content_adversary_optimizer.zero_grad()
sub_style_overall_optimizer.zero_grad()
# do not propagate loss to unrelated parameters
for param in self.m.style_adversary_params + self.m.content_adversary_params + self.m.style_overall_params:
param.requires_grad = False
for param in self.m.autoencoder_params:
param.requires_grad = True
composite_loss.backward(retain_graph=True)
for param in self.m.autoencoder_params + self.m.style_overall_params:
param.requires_grad = False
for param in self.m.style_adversary_params + self.m.content_adversary_params:
param.requires_grad = True
style_adversarial_loss.backward(retain_graph=True)
content_adversarial_loss.backward(retain_graph=True)
for param in self.m.autoencoder_params + self.m.style_adversary_params + self.m.content_adversary_params:
param.requires_grad = False
for param in self.m.style_overall_params:
param.requires_grad = True
style_overall_pred_loss.backward(retain_graph=True)
# reset to default
for param in self.m.autoencoder_params + self.m.style_adversary_params + self.m.content_adversary_params + self.m.style_overall_params:
param.requires_grad = True
torch.nn.utils.clip_grad_norm_(self.m.parameters(), self.mconf.grad_clip)
sub_autoencoder_optimizer.step()
sub_style_adversary_optimizer.step()
sub_content_adversary_optimizer.step()
sub_style_overall_optimizer.step()
if step == 0:
support_autoencoder_loss.append(composite_loss)
support_adv_style_loss.append(style_adversarial_loss)
support_adv_content_loss.append(content_adversarial_loss)
support_style_overall_loss.append(style_overall_pred_loss)
# query loss
batch_task = [query_batch[i][t] for i in range(len(query_batch))]
[
reconstruction_loss,
style_kl_loss, content_kl_loss,
style_multitask_loss, content_multitask_loss,
style_adversarial_entropy, content_adversarial_entropy,
style_adversarial_loss, content_adversarial_loss,
style_overall_pred_loss
] = self.m._feed_batch(
batch_task[0], batch_task[1], batch_task[2], batch_task[3],
gamma=gamma, style_kl_weight=style_kl_weight, content_kl_weight=content_kl_weight
)
'''
if style_adversarial_loss <= self.mconf.adv_loss_tolerance and content_adversarial_loss <= self.mconf.adv_loss_tolerance:
composite_loss = reconstruction_loss + style_kl_weight * style_kl_loss + content_kl_weight * content_kl_loss \
+ self.mconf.style_multitask_loss_weight * style_multitask_loss \
+ self.mconf.content_multitask_loss_weight * content_multitask_loss \
- self.mconf.style_adv_loss_weight * style_adversarial_entropy \
- self.mconf.content_adv_loss_weight * content_adversarial_entropy
else:
composite_loss = reconstruction_loss + style_kl_weight * style_kl_loss + content_kl_weight * content_kl_loss \
+ style_multitask_loss + content_multitask_loss
'''
composite_loss = reconstruction_loss + style_kl_weight * style_kl_loss + content_kl_weight * content_kl_loss \
+ self.mconf.style_multitask_loss_weight * style_multitask_loss \
+ self.mconf.content_multitask_loss_weight * content_multitask_loss \
- self.mconf.style_adv_loss_weight * style_adversarial_entropy \
- self.mconf.content_adv_loss_weight * content_adversarial_entropy
query_autoencoder_loss.append(composite_loss)
query_adv_style_loss.append(style_adversarial_loss)
query_adv_content_loss.append(content_adversarial_loss)
query_style_overall_loss.append(style_overall_pred_loss)
self.m.load_state_dict(init_state)
meta_autoencoder_loss = torch.stack(query_autoencoder_loss).sum(0) / self.num_tasks
meta_adv_style_loss = torch.stack(query_adv_style_loss).sum(0) / self.num_tasks
meta_adv_content_loss = torch.stack(query_adv_content_loss).sum(0) / self.num_tasks
meta_style_overall_loss = torch.stack(query_style_overall_loss).sum(0) / self.num_tasks
meta_autoencoder_optimizer.zero_grad()
meta_style_adversary_optimizer.zero_grad()
meta_content_adversary_optimizer.zero_grad()
meta_style_overall_optimizer.zero_grad()
# do not propagate loss to unrelated parameters
for param in self.m.style_adversary_params + self.m.content_adversary_params + self.m.style_overall_params:
param.requires_grad = False
for param in self.m.autoencoder_params:
param.requires_grad = True
meta_autoencoder_loss.backward(retain_graph=True)
for param in self.m.autoencoder_params + self.m.style_overall_params:
param.requires_grad = False
for param in self.m.style_adversary_params + self.m.content_adversary_params:
param.requires_grad = True
meta_adv_style_loss.backward(retain_graph=True)
meta_adv_content_loss.backward(retain_graph=True)
for param in self.m.autoencoder_params + self.m.style_adversary_params + self.m.content_adversary_params:
param.requires_grad = False
for param in self.m.style_overall_params:
param.requires_grad = True
meta_style_overall_loss.backward(retain_graph=True)
# reset to default
for param in self.m.autoencoder_params + self.m.style_adversary_params + self.m.content_adversary_params + self.m.style_overall_params:
param.requires_grad = True
torch.nn.utils.clip_grad_norm_(self.m.parameters(), self.mconf.grad_clip)
meta_autoencoder_optimizer.step()
meta_style_adversary_optimizer.step()
meta_content_adversary_optimizer.step()
meta_style_overall_optimizer.step()
init_state = copy.deepcopy(self.m.state_dict())
autoencoder_epoch_loss += meta_autoencoder_loss.item()
adversarial_epoch_loss += (meta_adv_style_loss + meta_adv_content_loss).item()
style_overall_epoch_loss += meta_style_overall_loss.item()
timestamp = dt.datetime.now().isoformat()
msg = "[{}]: batch {}/{}, epoch {}/{}, meta_vae {:g}, meta_adv_s {:g}, meta_adv_c {:g}, meta_overall_s {:g}".format(
timestamp, b + 1, num_batches, epoch + 1, epochs,
meta_autoencoder_loss.item(), meta_adv_style_loss.item(), meta_adv_content_loss.item(), meta_style_overall_loss.item()
)
for t in range(self.num_tasks):
msg += "\n\t(task-{}) support_vae {:g}, support_adv_s {:g}, support_adv_c {:g}, support_overall_s {:g}".format(
t + 1, support_autoencoder_loss[t].item(), support_adv_style_loss[t].item(),
support_adv_content_loss[t].item(), support_style_overall_loss[t].item()
)
msg += "\n\t(task-{}) query_vae {:g}, query_adv_s {:g}, query_adv_c {:g}, query_overall_s {:g}".format(
t + 1, query_autoencoder_loss[t].item(), query_adv_style_loss[t].item(),
query_adv_content_loss[t].item(), query_style_overall_loss[t].item()
)
print(msg)
gamma = max(self.mconf.gamma_min, gamma * self.mconf.gamma_decay)
print("-------")
print("epoch {}/{}: acc_vae_loss {:g}, acc_adv_loss {:g}, acc_style_ovrl {:g}".format(
epoch + 1, epochs, autoencoder_epoch_loss, adversarial_epoch_loss, style_overall_epoch_loss
))
print("\tgamma = {:g}, style_kl_weight = {:g}, content_kl_weight = {:g}".format(
gamma, style_kl_weight, content_kl_weight
))
def fine_tune(self, input_sequences_all, lengths_all, labels_all, bow_representations_all, batch_size, epochs, init_epoch=0):
self.m.train(input_sequences_all, lengths_all, labels_all, bow_representations_all, batch_size, epochs, init_epoch)
def get_batch_embeddings(self, input_sequences, lengths):
return self.m.get_batch_embeddings(input_sequences, lengths)
def infer(self, input_sequences, lengths, style_conditioning_embedding):
return self.m.infer(input_sequences, lengths, style_conditioning_embedding)
def save_model(self, path):
self.m.save_model(path)
def load_model(self, path):
self.m.load_model(path)
| [
"victoria-x@sjtu.edu.cn"
] | victoria-x@sjtu.edu.cn |
5d892f45bb5ed49a45551cf2fc71ed94bdb0fec8 | 91365d8ef539a9952f048e1fef03b6f76a0ccf60 | /test/inductor/test_torchinductor.py | 53d0bc4f376ee0abfd531abf66ebe0ea8c747a09 | [
"BSD-2-Clause",
"LicenseRef-scancode-secret-labs-2011",
"BSD-3-Clause",
"LicenseRef-scancode-generic-cla",
"BSL-1.0",
"Apache-2.0"
] | permissive | ppwwyyxx/pytorch | 6e68cd816e8197e298c50d7f0e82cc97aff4dbdf | 2883cb464810611c5de37b2ca06771582ddf5f83 | refs/heads/master | 2023-08-10T00:39:48.165007 | 2023-06-07T01:51:59 | 2023-06-07T01:51:59 | 160,557,191 | 3 | 3 | NOASSERTION | 2018-12-05T17:53:38 | 2018-12-05T17:53:37 | null | UTF-8 | Python | false | false | 208,514 | py | # Owner(s): ["module: inductor"]
import contextlib
import copy
import dataclasses
import functools
import importlib
import itertools
import math
import os
import random
import subprocess
import sys
import time
import typing
import unittest
import weakref
from typing import Tuple
from unittest.mock import patch
import numpy as np
import torch
import torch._dynamo
import torch.nn as nn
from torch._dispatch.python import enable_python_dispatcher
from torch._dynamo.testing import rand_strided, same
from torch._inductor.codegen.common import DataTypePropagation, OptimizationContext
from torch._inductor.utils import run_and_get_code, run_and_get_triton_code
from torch.fx.experimental.proxy_tensor import make_fx
from torch.nn import functional as F
from torch.testing import make_tensor
from torch.testing._internal.common_cuda import SM80OrLater
from torch.testing._internal.common_device_type import _has_sufficient_memory
from torch.testing._internal.common_dtype import all_types
from torch.testing._internal.common_utils import (
DeterministicGuard,
IS_CI,
IS_MACOS,
IS_WINDOWS,
IS_X86,
skipIfRocm,
TEST_WITH_ASAN,
TestCase as TorchTestCase,
)
from torch.utils._python_dispatch import TorchDispatchMode
from torch.utils._pytree import tree_flatten, tree_unflatten
if IS_WINDOWS and IS_CI:
sys.stderr.write(
"Windows CI does not have necessary dependencies for test_torchinductor yet\n"
)
if __name__ == "__main__":
sys.exit(0)
raise unittest.SkipTest("requires sympy/functorch/filelock")
importlib.import_module("functorch")
importlib.import_module("filelock")
from torch._inductor import config, test_operators
from torch._inductor.compile_fx import compile_fx, compile_fx_inner
from torch._inductor.utils import has_torchvision_roi_align
from torch.testing._internal.common_utils import slowTest
from torch.testing._internal.inductor_utils import HAS_CPU, HAS_CUDA
HAS_MULTIGPU = HAS_CUDA and torch.cuda.device_count() >= 2
HAS_AVX2 = "fbgemm" in torch.backends.quantized.supported_engines
aten = torch.ops.aten
requires_cuda = functools.partial(unittest.skipIf, not HAS_CUDA, "requires cuda")
requires_multigpu = functools.partial(
unittest.skipIf, not HAS_MULTIGPU, "requires multiple cuda devices"
)
skip_if_x86_mac = functools.partial(
unittest.skipIf, IS_MACOS and IS_X86, "Does not work on x86 Mac"
)
vec_dtypes = [torch.float, torch.bfloat16]
def run_fw_bw_and_get_code(fn):
def run_with_backward():
result = fn()
result.sum().backward()
return result
return run_and_get_code(run_with_backward)
class TestCase(TorchTestCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls._stack = contextlib.ExitStack()
cls._stack.enter_context(
config.patch(
{
"debug": True,
"debug_index_asserts": True,
"cpp.min_chunk_size": 1,
"triton.autotune_pointwise": False, # too slow
"implicit_fallbacks": False,
"generate_intermediate_hooks": True,
}
)
)
@classmethod
def tearDownClass(cls):
cls._stack.close()
super().tearDownClass()
def setUp(self):
torch._dynamo.reset()
super().setUp()
self._start = time.perf_counter()
def tearDown(self):
super().tearDown()
torch._dynamo.reset()
if os.environ.get("ERROR_ON_SLOW") == "1":
elapsed = time.perf_counter() - self._start
assert elapsed < 120
class ToTuple(torch.nn.Module):
def forward(self, x):
return (x,)
@dataclasses.dataclass
class InputGen:
n: int
device: str
def dense(self):
return torch.randn((self.n, self.n), device=self.device)
def transposed(self):
return self.dense().transpose(0, 1)
def strided(self):
return torch.randn((self.n * 2, self.n * 3), device=self.device)[
self.n :, self.n :: 2
]
def broadcast1(self):
return torch.randn((self.n,), device=self.device)
def broadcast2(self):
return torch.randn((1, self.n, 1), device=self.device)
def broadcast3(self):
return torch.randn((1,), device=self.device)
def double(self):
return torch.randn((self.n, self.n), device=self.device, dtype=torch.double)
def int(self):
return torch.arange(self.n, device=self.device, dtype=torch.int32)
def compute_grads(args, kwrags, results, grads):
def gather_leaf_tensors(args, kwargs):
args, _ = tree_flatten(args)
kwargs, _ = tree_flatten(kwargs)
args = args + kwargs
leaf_tensors = [
arg for arg in args if isinstance(arg, torch.Tensor) and arg.requires_grad
]
return leaf_tensors
flat_results, _ = tree_flatten(results)
flat_diff_results = [r for r in flat_results if r.requires_grad]
assert len(flat_diff_results) > 0
leaf_tensors = gather_leaf_tensors(args, kwrags)
assert len(leaf_tensors) > 0
return torch.autograd.grad(
flat_diff_results,
leaf_tensors,
grads,
allow_unused=True,
retain_graph=True,
)
def clone_preserve_strides(x, device=None):
if not isinstance(x, torch.Tensor):
return x
buffer = torch.as_strided(
x, (x.untyped_storage().size() // x.element_size(),), (1,), 0
)
if not device:
buffer = buffer.clone()
else:
buffer = buffer.to(device, copy=True)
out = torch.as_strided(buffer, x.size(), x.stride(), x.storage_offset())
return out
@patch.object(config, "debug", True)
def run_and_get_cpp_code(fn, *args, **kwargs):
torch._dynamo.reset()
import io
import logging
log_capture_string = io.StringIO()
ch = logging.StreamHandler(log_capture_string)
from torch._inductor.graph import output_code_log
output_code_log.addHandler(ch)
prev_level = output_code_log.level
output_code_log.setLevel(logging.DEBUG)
fn(*args, **kwargs)
s = log_capture_string.getvalue()
output_code_log.setLevel(prev_level)
output_code_log.removeHandler(ch)
return s
def check_model(
self: TestCase,
model,
example_inputs,
kwargs=None,
*,
atol=None,
rtol=None,
check_lowp=True,
exact_dtype=True,
nopython=True,
copy_to_cuda=True,
reference_in_float=True,
assert_equal=True,
check_gradient=False,
):
kwargs = kwargs or {}
torch._dynamo.reset()
ref_inputs = [clone_preserve_strides(x) for x in example_inputs]
ref_kwargs = kwargs
has_lowp_args = False
original_lowp_dtype = torch.half
if reference_in_float:
# check_lowp is ignored here, it's kept just to be able to call `common` with extra arg
def upcast_fn(x):
nonlocal has_lowp_args
if isinstance(x, torch.Tensor) and (
x.dtype == torch.float16 or x.dtype == torch.bfloat16
):
has_lowp_args = True
return x.float()
else:
return x
def get_original_lowp_dtype(example_inputs):
dtypes = [x.dtype for x in example_inputs if isinstance(x, torch.Tensor)]
dtype_set = set(dtypes)
return dtype_set.pop() if len(dtype_set) == 1 else torch.half
ref_inputs = list(map(upcast_fn, example_inputs))
ref_kwargs = {k: upcast_fn(v) for k, v in kwargs.items()}
if has_lowp_args:
original_lowp_dtype = get_original_lowp_dtype(example_inputs)
if hasattr(model, "to"):
model = model.to(torch.float)
torch.manual_seed(0)
correct = model(*ref_inputs, **ref_kwargs)
# downcast the model back if needed
if reference_in_float and has_lowp_args:
if hasattr(model, "to"):
model = model.to(original_lowp_dtype)
torch._inductor.metrics.reset()
called = False
def compile_fx_wrapper(model_, example_inputs_):
nonlocal called
called = True
return compile_fx(model_, example_inputs_)
def run(*ex, **kwargs):
return model(*ex, **kwargs)
run = torch._dynamo.optimize(compile_fx_wrapper, nopython=nopython)(run)
torch.manual_seed(0)
actual = run(*example_inputs, **kwargs)
# if not called:
# exp = torch._dynamo.explain(run, *example_inputs)
# print("Explain:", exp[0])
# for graph in exp[2]:
# print("Graph", graph)
assert called, "Ran graph without calling compile_fx"
assert type(actual) == type(correct)
correct_flat, correct_spec = tree_flatten(correct)
actual_flat, _ = tree_flatten(actual)
if reference_in_float:
correct_flat = tuple(
y.to(x.dtype)
if isinstance(y, torch.Tensor) and y.dtype.is_floating_point
else y
for x, y in zip(actual_flat, correct_flat)
)
correct = tree_unflatten(correct_flat, correct_spec)
if assert_equal:
self.assertEqual(
actual,
correct,
atol=atol,
rtol=rtol,
equal_nan=True,
exact_dtype=exact_dtype,
)
# In case of input mutations, check that inputs are the same
self.assertEqual(
ref_inputs,
example_inputs,
atol=atol,
rtol=rtol,
equal_nan=True,
# our testing sometimes uses higher precision inputs for the reference
exact_dtype=False,
)
else:
for correct_val, actual_val in zip(correct_flat, actual_flat):
if isinstance(correct_val, torch.Tensor):
assert correct_val.device == actual_val.device
assert correct_val.size() == actual_val.size()
assert correct_val.stride() == actual_val.stride()
assert correct_val.layout == actual_val.layout
if exact_dtype:
assert correct_val.dtype == actual_val.dtype
if check_gradient:
# generate random unit norm gradients
grads = [
torch.rand(r.shape, device=r.device, dtype=r.dtype)
for r in correct_flat
if r.requires_grad
]
for g in grads:
g /= g.norm()
correct_grad = compute_grads(ref_inputs, ref_kwargs, correct, grads)
flat_grads, _ = tree_flatten(correct_grad)
all_none_grads = all(x is None for x in flat_grads)
if all_none_grads:
# See Note [Detaching inputs that never need gradients]
# There are a handful of ops that can return None gradients, into of zero gradients.
# If all inputs to an AOTAutograd graph are supposed to get None gradients,
# AOTAutograd will end up forcing all of the outputs of the forward to not require grad.
# There's no easy fix to this (see the note above), although one option is to
# force any derivative formulas in core to return tensors of zeros instead of None.
flat_results, _ = tree_flatten(actual)
results_that_require_grad = [
x
for x in flat_results
if isinstance(x, torch.Tensor) and x.requires_grad
]
self.assertEqual(len(results_that_require_grad), 0)
else:
actual_grad = compute_grads(example_inputs, kwargs, actual, grads)
self.assertEqual(
actual_grad,
correct_grad,
atol=atol,
rtol=rtol,
equal_nan=True,
exact_dtype=exact_dtype,
)
torch._dynamo.reset()
@torch._inductor.config.patch("triton.cudagraphs", False)
def check_model_cuda(
self: TestCase,
model,
example_inputs,
kwargs=None,
*,
atol=None,
rtol=None,
check_lowp=True,
exact_dtype=True,
nopython=True,
copy_to_cuda=True,
reference_in_float=True,
assert_equal=True,
check_gradient=False,
):
kwargs = kwargs or {}
if hasattr(model, "to"):
model = model.to("cuda")
if copy_to_cuda:
example_inputs = tuple(
clone_preserve_strides(x, device="cuda") for x in example_inputs
)
check_model(
self,
model,
example_inputs,
kwargs,
atol=atol,
rtol=rtol,
exact_dtype=exact_dtype,
nopython=nopython,
reference_in_float=reference_in_float,
assert_equal=assert_equal,
check_gradient=check_gradient,
)
if check_lowp:
def downcast_fn(x):
if not isinstance(x, torch.Tensor) or not x.dtype == torch.float:
return x
return torch.empty_strided(
x.size(), x.stride(), device="cuda", dtype=torch.half
).copy_(x)
example_inputs = list(map(downcast_fn, example_inputs))
if hasattr(model, "to"):
model = model.to(torch.half)
if rtol is not None:
rtol = max(2e-3, rtol)
check_model(
self,
model,
example_inputs,
kwargs,
atol=atol,
rtol=rtol,
exact_dtype=exact_dtype,
nopython=nopython,
reference_in_float=reference_in_float,
assert_equal=assert_equal,
check_gradient=check_gradient,
)
def _run_and_assert_no_indirect_indexing(test_case, func, *args, **kwargs):
result, source_codes = run_and_get_code(func, *args, **kwargs)
for code in source_codes:
for line in code.split("\n"):
stmt = None
# Find indexing expressions
if ".load(" in line:
stmt = line.split(".load")[-1]
elif "tl.store" in line:
stmt = line.split(".store")[-1]
stmt = ",".join(stmt.split(",")[:-2]) # Remove store value and mask
elif ".store" in line:
stmt = line.split(".store")[-1]
elif "[" in line:
stmt = line.split("[")[-1].split("]")[0]
if stmt is None:
continue
# indirect indexing involves a `tmp` variable
test_case.assertTrue(
"tmp" not in stmt,
msg=f"Found indirect indexing in statement '{stmt}' from code:\n{code}",
)
return result
class SweepInputs2:
input_gen_types1 = [
"dense",
"transposed",
"strided",
"broadcast1",
"broadcast2",
"broadcast3",
"double",
"int",
]
input_gen_types2 = input_gen_types1
gen = None
@staticmethod
def kernel(a, b):
return (a + b,)
@classmethod
def gen_template(cls, name1, name2):
def test(self):
check_model(
self,
cls.kernel,
(
getattr(cls.gen, name1)(),
getattr(cls.gen, name2)(),
),
)
test.__name__ = f"test_{cls.gen.device}_{name1}_{name2}"
setattr(cls, test.__name__, test)
@classmethod
def populate(cls):
for name1 in cls.input_gen_types1:
for name2 in cls.input_gen_types2:
cls.gen_template(name1, name2)
class CommonTemplate:
def test_bool(self):
def fn(a, b):
return (
a + b,
a * b,
a & b,
a | b,
a ^ b,
torch.logical_and(a, b),
torch.logical_or(a, b),
torch.logical_not(a),
torch.sign(b),
)
self.common(
fn,
(
torch.tensor([True, False, True, False]),
torch.tensor([False, False, True, True]),
),
)
def test_add_const_int(self):
def fn(a):
return (a + 1, torch.add(a, 1, alpha=2))
self.common(fn, (torch.randn(32),))
def test_add_const_float(self):
def fn(a):
return (a + 1.5,)
self.common(fn, (torch.randn(32),))
def test_add_inplace_permuted(self):
def fn(x, y):
return x.add_(y)
x = torch.ones([2, 12, 13, 17]).transpose(1, 2)
y = torch.randn([2, 13, 1, 17])
self.common(fn, (x, y))
def test_concat_add_inplace(self):
def fn(x, y, z):
return torch.cat([x, y], dim=1).add_(z)
x = torch.randn([2, 12, 14, 14])
y = torch.randn([2, 12, 14, 14])
z = torch.randn([2, 24, 14, 14])
self.common(fn, (x, y, z))
def test_abs(self):
def fn(a):
return (a / (torch.abs(a) + 1),)
self.common(fn, (torch.randn(17),))
def test_sgn(self):
def fn(a):
return torch.sgn(a), torch.sgn(a + 1) - 1
self.common(fn, [torch.linspace(-10, 10, 41)])
def test_randn_generator(self):
def fn(a, generator):
torch.randn([20, 20], generator=generator, device=a.device)
self.common(fn, (torch.linspace(-10, 10, 41), None))
# generator not yet supported in dynamo
with self.assertRaisesRegex(torch._dynamo.exc.Unsupported, "Generator"):
self.common(fn, (torch.linspace(-10, 10, 41), torch.Generator(self.device)))
def test_sgn_extremal(self):
def fn(a):
return (torch.sgn(a),)
self.common(fn, [torch.tensor([np.nan, np.inf, -np.inf, 0])])
def test_max_min(self):
def fn(a, b):
return (torch.maximum(a, b), torch.minimum(a, b))
self.common(fn, (torch.randn(8), torch.randn(8)))
t1 = torch.randn(8)
t1[0] = float("nan")
t2 = torch.randn(8)
t2[1] = float("nan")
self.common(fn, (t1, t2))
def test_neg_max_uint8(self):
# https://github.com/pytorch/pytorch/issues/93380
def fn(a, b):
c = torch.neg(a)
return torch.maximum(b, c)
a = torch.randint(256, (1,), dtype=torch.uint8)
b = torch.randint(256, (8390,), dtype=torch.uint8)
self.common(fn, (a, b))
def test_compar(self):
def fn(x):
return x.gt(3.5), x.ge(3.5), x.eq(3.5), x.le(2.5), x.lt(3.5), x.ne(3.5)
a = torch.tensor([3])
self.common(fn, (a,))
def test_horizonal_fusion1(self):
def fn(a, b, c):
return (a + b, a - c, b * c)
self.common(
fn, (torch.randn(8, 16, 16), torch.randn(8, 16, 16), torch.randn(1, 16, 1))
)
def test_horizonal_fusion2(self):
def fn(a, b, c):
return a + 1, b + 2, c + 3
self.common(fn, (torch.randn(8, 16, 8), torch.randn(8, 16), torch.randn(16, 8)))
def test_vertical_fusion1(self):
def fn(sa, ct, p):
# From torchbench.pyhpc_equation_of_state
v17 = -3.087032500374211e-7
v18 = -1.988366587925593e-8
v19 = -1.061519070296458e-11
v20 = 1.550932729220080e-10
t15 = v19 * ct
t19 = v17 + ct * (v18 + t15) + v20 * sa
t20 = 1.0 / t19
t128 = t19 * p
return t20 + t128
self.common(
fn,
(
torch.randn(204, 204, 26),
torch.randn(204, 204, 26),
torch.randn(26),
),
)
self.assertEqual(torch._inductor.metrics.generated_kernel_count, 1)
def test_forced_buffer_realize(self):
# Test torch._test_inductor_realize forces a buffer to be realized
def fn(a):
b = test_operators.realize(a * 2)
return (b * 2,)
self.common(fn, (torch.randn(10),))
self.assertEqual(torch._inductor.metrics.ir_nodes_pre_fusion, 2)
def test_scheduler_vertical_fusion1(self):
realize = test_operators.realize
def fn(sa, ct, p):
# From torchbench.pyhpc_equation_of_state
v17 = -3.087032500374211e-7
v18 = -1.988366587925593e-8
v19 = -1.061519070296458e-11
v20 = 1.550932729220080e-10
t15 = realize(v19 * ct)
t19 = realize(v17 + ct * (v18 + t15) + v20 * sa)
t20 = realize(1.0 / t19)
t128 = realize(t19 * p)
return t20 + t128
self.common(
fn,
(
torch.randn(204, 204, 26),
torch.randn(204, 204, 26),
torch.randn(26),
),
)
self.assertEqual(torch._inductor.metrics.ir_nodes_pre_fusion, 5)
self.assertEqual(
torch._inductor.metrics.generated_kernel_count,
1 if self.device == "cuda" else 3,
)
def test_index_propagation(self):
def flip(x):
i = torch.arange(x.size(0) - 1, -1, -1, device=x.device)
return x[i]
x = torch.randn(8, device=self.device)
flip_opt = torch._dynamo.optimize("inductor")(flip)
expect = flip(x)
actual = _run_and_assert_no_indirect_indexing(self, flip_opt, x)
self.assertEqual(expect, actual)
def test_index_propagation_floordiv(self):
def repeat_interleave(x, n):
# e.g. x=[1, 2, 3], n=2 => returns [1, 1, 2, 2, 3, 3]
i = torch.arange(x.shape[0] * n, device=x.device)
return x[i // n]
x = torch.randn(8, device=self.device)
repeat_interleave_opt = torch._dynamo.optimize("inductor")(repeat_interleave)
# this should be collapsed to direct indexing
actual = _run_and_assert_no_indirect_indexing(self, repeat_interleave_opt, x, 3)
expect = torch.repeat_interleave(x, 3)
self.assertEqual(expect, actual)
self.assertEqual(actual, repeat_interleave(x, 3))
def test_index_propagation_remainder(self):
def repeat(x, n):
# e.g. x=[1, 2, 3], n=2 => returns [1, 2, 3, 1, 2, 3]
i = torch.arange(x.shape[0] * n, device=x.device)
return x[i % x.shape[0]]
x = torch.randn(8, device=self.device)
repeat_opt = torch._dynamo.optimize("inductor")(repeat)
# this should be collapsed to direct indexing
actual = _run_and_assert_no_indirect_indexing(self, repeat_opt, x, 3)
expect = x.repeat(3)
self.assertEqual(expect, actual)
self.assertEqual(actual, repeat(x, 3))
def test_computed_buffer_inlining(self):
def flip(x):
idx = torch.arange(x.size(0) - 1, -1, -1, device=x.device)
return x[idx], idx
flip_opt = torch._dynamo.optimize("inductor")(flip)
x = torch.randn(8, device=self.device)
expect = flip(x)
actual = _run_and_assert_no_indirect_indexing(self, flip_opt, x)
self.assertEqual(expect, actual)
def test_sum1(self):
def fn(a, b):
return ((a + b).sum(-1),)
self.common(fn, (torch.randn(8, 8), torch.randn(8, 8)))
def test_sum2(self):
def fn(a, b):
return ((a + b).sum([1, 2]), (a + b).sum(-1))
self.common(fn, (torch.randn(8, 9, 3, 21), torch.randn(8, 9, 3, 21)))
def test_sum3(self):
def fn(a, b):
r1 = a + b
r2 = r1.sum(-1)
r3 = torch.squeeze(b) + 10
return (r1, r2, r3)
# Mismatched elements: 2 / 10 (20.0%)
# Greatest absolute difference: 0.0029296875 at index (8,) (up to 1e-05 allowed)
# Greatest relative difference: 0.0017482517482517483 at index (6,) (up to 0.001 allowed)
self.common(fn, (torch.randn(10, 10), torch.randn(1, 10)), atol=1e-5, rtol=2e-3)
def test_sum4(self):
def fn(a):
b = a + 1
c = b.sum(-1)
d = c + 3
e = d.sum(-1)
f = e + 5
return (f, e, d, c, b)
self.common(fn, (torch.randn(1, 16, 8, 8),))
def test_sum5(self):
def fn(a):
b = a + 1
c = b.sum(-1)
d = c + 3
e = d.sum(-1)
f = e + 5
return (f,)
self.common(fn, (torch.randn(1, 17, 8, 9),))
def test_reduction1(self):
def fn(a):
return (a.sum(), a.max(), a.min(), a.argmax(), a.argmin())
self.common(fn, (torch.tensor([float("-inf"), 0.0, float("inf")]),))
@skip_if_x86_mac()
def test_reduction2(self):
def fn(a):
# FIXME: a.argmax
return (a.sum(), a.max(), a.min(), a.argmin())
self.common(fn, (torch.full((4,), float("inf")),))
@skip_if_x86_mac()
def test_reduction3(self):
def fn(a):
# FIXME: a.argmin
return (a.sum(), a.max(), a.min(), a.argmax())
self.common(fn, (torch.full((4,), float("-inf")),))
def test_reduction4(self):
if self.device == "cpu":
raise unittest.SkipTest("Non-deterministic CPU results")
def fn(a):
return (a.argmax(-1), a.argmin(-1))
inputs = (torch.ones(128), torch.ones(4, 4, 1))
for i in inputs:
self.common(fn, (i,))
@config.patch(unroll_reductions_threshold=1)
def test_reduction5(self):
if self.device == "cpu":
raise unittest.SkipTest("Non-deterministic CPU results")
def fn(a):
return (a.sum(), a.max(), a.min(), a.argmax())
self.common(fn, (torch.full((4,), float("-inf")),))
def test_prod(self):
def fn(a):
return a.prod(0), a.prod(1), a.prod()
self.common(fn, (torch.rand((10, 10)),))
self.common(fn, (torch.rand((1, 2050)),))
def test_unroll_small_reduction(self):
def fn(x):
val1, index1 = x.min(-1)
val2, index2 = x.max(-1)
return (
val1,
index1,
val2,
index2,
x.sum(-1),
(x > 1).any(-1),
(x > 0).all(-1),
x.argmin(-1),
x.argmax(-1),
x.amin(-1),
x.amax(-1),
x.aminmax(),
)
with config.patch(unroll_reductions_threshold=8):
# small sized reductions will get unrolled
self.common(fn, (torch.randn(8, 3),))
torch._dynamo.reset()
with config.patch(unroll_reductions_threshold=1):
# make sure things also work if they aren't unrolled
self.common(fn, (torch.randn(8, 3),))
def test_multilayer_low_prec(self):
# fp16 nyi for cpu
if self.device == "cpu":
raise unittest.SkipTest("requires CUDA")
def fn(a):
return torch.mean(a)
self.common(fn, ((torch.rand((10, 3, 352, 352), dtype=torch.float16),)))
def test_expanded_reduction(self):
if self.device == "cpu":
raise unittest.SkipTest(
"https://github.com/pytorch/torchdynamo/issues/1697"
)
def fn(x, y):
z = x * y
return z.sum((0, 1))
self.common(fn, (torch.randn(2, 197, 256), torch.randn(2, 1, 256)))
def test_min_max_reduction(self):
def fn(a, b):
return (
(a + b).max(),
(a + b).min(),
torch.amax(a + 1, keepdim=True),
torch.amin(b + 1, keepdim=True),
)
dtypes = [torch.float, torch.float16]
if not (self.device == "cuda" and not SM80OrLater):
dtypes += [torch.bfloat16]
for dtype in dtypes:
self.common(fn, (torch.randn(8, 8).to(dtype), torch.randn(8, 8).to(dtype)))
def test_min_max_reduction_nan(self):
def fn(a):
return (torch.max(a), torch.min(a))
t1 = torch.randn(32)
t1[16] = float("nan")
self.common(fn, (t1,))
def test_fmin_fmax(self):
def fn(a, b):
return (
torch.fmin(a, b),
torch.fmax(a, b),
torch.fmax(a + 1, torch.tensor(0.0)),
)
self.common(
fn,
(
torch.tensor(
[-10.0, 10.0, float("nan"), float("nan"), float("nan"), 3, 4]
),
torch.tensor(
[float("nan"), float("nan"), -10.0, 10.0, float("nan"), 4, 3]
),
),
)
def test_sum_int(self):
def fn(x):
return 2 * x.sum(-1) + x.sum()
dtypes = torch.bool, torch.uint8, torch.int
inps = [torch.randint(2, (64,), dtype=dtype) for dtype in dtypes]
for i in inps:
self.common(fn, (i,), check_lowp=False)
def test_sum_dtype(self):
def fn(x):
return x * x.sum(-1, dtype=torch.double) + x.sum(dtype=torch.double)
self.common(fn, (torch.ones(32, 32) * 70,))
def test_clamp(self):
def fn(a, b):
return (a.clamp(-0.1, 0.1), b.clamp(0), torch.clamp(a + b, max=0))
self.common(fn, (torch.randn(8, 8), torch.randn(8, 8)))
def test_clamp_type_promotion(self):
def fn(a):
b = torch.tensor(1.0, dtype=torch.double, device=self.device)
c = torch.full((4,), 2, device=self.device)
return a.clamp(min=b, max=c)
self.common(fn, (torch.randint(4, (4,)),))
def test_arange1(self):
def fn(x):
rng1 = torch.arange(8 * 8, dtype=torch.float32, device=x.device).view(8, 8)
rng2 = torch.arange(10, 18, device=x.device)
tmp = x * rng1
return tmp, tmp + rng2
self.common(fn, (torch.randn(8, 8),))
def test_arange2(self):
def fn(x):
rng1 = torch.arange(8, device=x.device)
return (x + rng1,)
self.common(fn, (torch.randint(4, (8, 8)),), check_lowp=False)
def test_arange3(self):
def fn(x):
return x + torch.ops.aten.arange.start_step(
0, 53, 4, dtype=torch.int64, device=x.device
)
self.common(fn, (torch.randn(14),))
def test_arange4(self):
def fn(x):
return x - torch.arange(512, -512, -1.0, device=x.device)
self.common(fn, (torch.randn(1024),))
def test_arange5(self):
def fn(step, device):
return torch.arange(512, -512, step, device=device)
compiled_fn = torch._dynamo.optimize()(fn)
# NOTE: use assertEqual to check dtypes which self.common doesn't do
for step in (-1, -1.0):
expect = fn(step, self.device)
actual = compiled_fn(step, self.device)
self.assertEqual(expect, actual)
self.assertEqual(expect, actual)
def test_arange6(self):
def fn(x):
return torch.arange(0.1, 8.0001, 1, dtype=x.dtype, device=x.device)
# Test that float arguments are truncated to int when dtype is set explicitly
make_arg = functools.partial(make_tensor, device="cpu", requires_grad=False)
self.common(fn, (make_arg(1, dtype=torch.float32),))
self.common(fn, (make_arg(1, dtype=torch.int64),))
def test_linspace1(self):
def fn(x):
return torch.linspace(0.125, 0.875, 7, device=x.device) + x
self.common(fn, (torch.randn(1, 7),))
def test_linspace2(self):
def fn(x):
return torch.linspace(0, 2, 1, device=x.device) + x
self.common(fn, (torch.randn(1, 1),))
def test_linspace3(self):
def fn(x):
return torch.linspace(0, 2, 0, device=x.device)
self.common(fn, (torch.Tensor([]),))
def test_tensor1(self):
def fn(x):
return torch.tensor([1], device=x.device) + x, torch.tensor(
5, device=x.device
)
self.common(fn, (torch.randn(10),))
def test_tensor2(self):
def fn(x):
return torch.tensor(list(range(2, 40, 2)), device=x.device) + x
self.common(fn, (torch.randn(1),))
def test_tensor3(self):
def fn(x):
return (
torch.tensor([], device=x.device),
torch.tensor([1, 2], device=x.device) + 1,
torch.tensor([1, 2, 3], device=x.device) + 2,
torch.tensor([1, 2, 3, 4], device=x.device) + x,
)
self.common(fn, [torch.randn(4)])
def test_views1(self):
def fn1(x, y):
return (x.view(size2) + y,)
def fn2(x, y):
return ((x + 1).view(size2) + y,)
views = [
([5 * 7], [5, 7]),
([2 * 3 * 4 * 5 * 6 * 7], [2, 3, 4, 5, 6, 7]),
([2 * 3, 4, 5, 6 * 7], [2, 3, 4, 5, 6, 7]),
([10 * 5, 20], [10, 5, 20]),
([1, 10, 1], [10]),
([10, 1, 10, 1, 10], [10, 100]),
([2, 2, 2, 2], [4, 4]),
]
for size1, size2 in views:
self.common(fn1, (torch.randn(size1), torch.randn(size2)))
self.common(fn2, (torch.randn(size1), torch.randn(size2)))
for size2, size1 in views:
self.common(fn1, (torch.randn(size1), torch.randn(size2)))
self.common(fn2, (torch.randn(size1), torch.randn(size2)))
def test_views2(self):
def fn1(x):
return (x.view(size2) + 1,)
def fn2(x):
return ((x * 2).view(size2) + 1,)
for size1, size2 in [
([2, 2, 2, 2], [4, -1]),
([10, 1, 10, 1, 10], [-1, 100]),
([10 * 5, 20], [10, -1, 20]),
]:
self.common(fn1, (torch.randn(size1),))
self.common(fn2, (torch.randn(size1),))
def test_views3(self):
# example taken from hf_BigBird
def forward(arg1, arg2):
index = torch.ops.aten.index(arg1, [arg2])
view_1 = torch.ops.aten.view(index, [1, 2232, 64])
view_2 = torch.ops.aten.view(view_1, [1, 12, 62, 192])
return view_2
self.common(
forward,
(
rand_strided((64, 64), (64, 1), torch.float32),
rand_strided((2232,), (1,), torch.int64),
),
)
def test_views4(self):
# example taken from hf_BigBird
def forward(arg1, arg2):
arg1 = arg1.index_select(0, arg2)
arg1 = torch.ops.aten.view(arg1, [2, 3, 4, 5, 5])
arg1 = torch.ops.aten.view(arg1, [2, 3, 2, 10, -1])
return arg1
self.common(
forward,
(
torch.randn(12, 5, 5),
torch.randint(0, 11, (24,)),
),
)
def test_views5(self):
# tensor with shape 0 in any dimension
def forward(x):
y = x[:, 4:]
return y.view(len(y), -1, 4)
self.common(
forward,
(torch.randn(4, 4, 4, 4),),
)
def test_views6(self):
def forward(x):
x = torch.ops.aten.relu(x)
s = torch.ops.aten.slice(x, 0, 0, 9223372036854775807)
s = torch.ops.aten.slice(s, 1, 0, 9223372036854775807)
s = torch.ops.aten.slice(s, 3, 0, 0)
y = torch.ops.aten.view(s, [4, 2, -1])
return y
self.common(
forward,
(torch.randn(4, 2, 4, 4),),
)
def test_relu(self):
def fn(a, b):
return (torch.relu(a), torch.relu(a + b) / 10)
self.common(fn, (torch.randn(8, 8), torch.randn(8, 8)))
def test_exp(self):
def fn(a, b):
return (torch.exp(a), torch.exp(a + b))
self.common(fn, (torch.randn(8, 8), torch.randn(8, 8)))
def test_exp2(self):
def fn(a, b):
return (torch.exp2(a), torch.exp2(a + b), torch.pow(2, -torch.abs(a - b)))
self.common(fn, (torch.randn(8, 8), torch.randn(8, 8)))
def test_sigmoid(self):
def fn(a, b):
return (torch.sigmoid(a), torch.sigmoid(a + b))
self.common(fn, (torch.randn(8, 8), torch.randn(8, 8)))
def test_round(self):
def fn(a, b):
return torch.round(a), torch.round(b + 1), torch.round(a, decimals=2)
# without manual_seed, there is some chance this test fails due to:
# https://github.com/openai/triton/issues/530
torch.manual_seed(0)
# with *100 we are always getting a number exactly at .5 which we don't do right in half
self.common(fn, (torch.randn(8, 8) * 100, torch.randn(8, 8) * 10))
def test_round_correctness(self):
if self.device == "cuda":
raise unittest.SkipTest("need to debug tl.libdevice on A100/V100")
def fn(a):
return torch.round(a)
self.common(
fn,
[torch.arange(-10, 10, 0.1, dtype=torch.float64)],
check_lowp=False,
)
def test_silu(self):
def fn(a):
return (torch.nn.functional.silu(a),)
self.common(fn, (torch.randn(8, 8),))
# TODO(voz): Re-enable this test ASAP https://github.com/pytorch/pytorch/issues/82763
@unittest.skip("Skipping due to op bugs")
def test_nan_to_num(self):
def fn(a):
return (
torch.nan_to_num(a),
torch.nan_to_num(a, nan=3.0),
torch.nan_to_num(a, nan=None),
torch.nan_to_num(a, posinf=4.0),
torch.nan_to_num(a, neginf=5.0),
torch.nan_to_num(a, nan=3.0, posinf=4.0, neginf=5.0),
)
self.common(
fn,
(torch.tensor((float("nan"), float("inf"), float("-inf"), 1.0)),),
check_lowp=False, # a much more elaborate test is required to match finfo max's for float and half
)
def test_div1(self):
def fn(a, b):
return (
aten.div(a, b, rounding_mode=None),
aten.div(a, b, rounding_mode="floor"),
aten.div(a, b, rounding_mode="trunc"),
a / b,
a // b,
)
self.common(fn, (torch.randn(8, 8) * 100, torch.randn(8, 8) * 100))
def test_div2(self):
def fn(a, b):
return (
aten.div(a, b, rounding_mode=None),
aten.div(a, b, rounding_mode="floor"),
aten.div(a, b, rounding_mode="trunc"),
a / b,
a // b,
)
self.common(fn, (torch.randint(-100, 100, [8, 8]), 100 * torch.randn(8, 8)))
def test_div3(self):
def fn(a, b):
return (
aten.div(a, b, rounding_mode=None),
aten.div(a, b, rounding_mode="floor"),
aten.div(a, b, rounding_mode="trunc"),
a / b,
a // b,
)
a = torch.randint(1, 100, [8, 8])
self.common(fn, (a * 2, a))
def test_div4(self):
def fn(a, b):
return (
aten.div(a, b, rounding_mode=None),
aten.div(a, b, rounding_mode="floor"),
aten.div(a, b, rounding_mode="trunc"),
a / b,
a // b,
)
self.common(
fn,
(torch.randint(-100, 0, [8, 8]), torch.randint(1, 10, [8, 8])),
)
def test_div5(self):
def fn(a, b):
return (
aten.div(a, b, rounding_mode=None),
aten.div(a, b, rounding_mode="floor"),
aten.div(a, b, rounding_mode="trunc"),
a / b,
a // b,
)
# divide a scalar
self.common(fn, (torch.randint(-100, 0, [8, 8]), 16))
def test_div6(self):
def fn(a, b):
return (
aten.div(a, b, rounding_mode=None),
aten.div(a, b, rounding_mode="floor"),
aten.div(a, b, rounding_mode="trunc"),
a / b,
a // b,
)
# treat boolean as integer
self.common(
fn,
(torch.ones([8, 8], dtype=torch.bool), torch.randint(-100, -1, [8, 8])),
)
def test_div7(self):
def fn(a, b):
return (
aten.div(a, b, rounding_mode=None),
aten.div(a, b, rounding_mode="floor"),
aten.div(a, b, rounding_mode="trunc"),
a / b,
a // b,
)
self.common(
fn,
(
torch.randint(2**32, 2**40, [100, 100]),
torch.randint(-10, -1, [100, 100]),
),
)
def test_div8(self):
def fn(a, b):
return (
aten.div(a, b, rounding_mode=None),
aten.div(a, b, rounding_mode="floor"),
aten.div(a, b, rounding_mode="trunc"),
a / b,
a // b,
)
self.common(fn, (1024, 100))
def test_div_zero_dim(self):
def fn(a, b):
return (
aten.div(a, b, rounding_mode=None),
aten.div(a, b, rounding_mode="floor"),
aten.div(a, b, rounding_mode="trunc"),
a / b,
a // b,
)
for dtype in (torch.float32, torch.int64):
self.common(
fn,
(
make_tensor(10, device="cpu", dtype=dtype),
make_tensor((), device="cpu", dtype=dtype, exclude_zero=True),
),
)
self.common(
fn,
(
make_tensor((), device="cpu", dtype=dtype),
make_tensor(10, device="cpu", dtype=dtype, exclude_zero=True),
),
)
def test_div_prim(self):
def fn(a, b):
return (torch.ops.prims.div(a, b),)
for dtype in (torch.float32, torch.int64):
self.common(
fn,
(
make_tensor(100, device="cpu", dtype=dtype),
make_tensor(100, device="cpu", dtype=dtype, exclude_zero=True),
),
)
def test_both_scalars(self):
def fn(a, b):
return (
aten.add(a, b),
aten.add(b, a),
aten.sub(a, b),
aten.sub(b, a),
aten.mul(a, b),
aten.mul(b, a),
)
self.common(fn, (4, 3.3), reference_in_float=False)
def test_sum_keepdims(self):
def fn(a, b):
return (torch.sum(a + b, -1, keepdim=True),)
self.common(fn, (torch.randn(8, 8), torch.randn(8, 8)))
def test_large_tensor_reduction(self):
if not _has_sufficient_memory(self.device, 4.5 * 1024**3): # 4.5 GiB
raise unittest.SkipTest("insufficient memory")
if self.device == "cpu":
raise unittest.SkipTest("Fails on CPU")
# Test 64-bit indexing works correctly
def fn(a):
return torch.max(a)
t = torch.ones(2**32, dtype=torch.int8, device=self.device)
t[-1] = 2
# self.common OOMs here because it copies inputs to check for mutations
compiled_fn = torch._dynamo.optimize()(fn)
actual = compiled_fn(t)
expect = torch.tensor(2, dtype=torch.int8, device=self.device)
self.assertEqual(actual, expect)
def test_large_broadcast_reduction(self):
if self.device == "cpu":
raise unittest.SkipTest("Fails on CPU")
# Test 64-bit indexing works correctly when inputs are less than 32-bit
# but intermediate tensors require 64-bit indexing
def fn(a, b):
return torch.max(a + b)
t1 = torch.ones(1, 2**16, dtype=torch.int8, device=self.device)
t2 = torch.ones(2**16, 1, dtype=torch.int8, device=self.device)
t1[-1, -1] = 2
t2[-1, -1] = 2
# self.common OOMs here because it copies inputs to check for mutations
compiled_fn = torch._dynamo.optimize()(fn)
actual = compiled_fn(t1, t2)
expect = torch.tensor(4, dtype=torch.int8, device=self.device)
self.assertEqual(actual, expect)
def test_large_pointwise(self):
if not _has_sufficient_memory(self.device, 2 * (2**31 + 1)):
raise unittest.SkipTest("insufficient memory")
def fn(a):
return a + 1
t = torch.ones(2**31 + 1, dtype=torch.int8, device=self.device)
compiled_fn = torch._dynamo.optimize()(fn)
actual = compiled_fn(t)
# Can't use assertEqual as it expands broadcasted inputs
del t
if torch.device(self.device).type == "cuda":
torch.cuda.empty_cache()
self.assertTrue((actual == 2).all())
def test_large_offset_pointwise(self):
# Test 64-bit indexing is used when input views a tensor that can be
# indexed with 32-bit strides but the storage offset pushes it over
# INT_MAX
if not _has_sufficient_memory(self.device, (2**31 + 1) + (2**30 + 1)):
raise unittest.SkipTest("insufficient memory")
def fn(a):
return a + 4
t = torch.ones(2**31 + 1, dtype=torch.int8, device=self.device)
t[2**30 :] = 0
compiled_fn = torch._dynamo.optimize()(fn)
actual = compiled_fn(t[2**30 :])
self.assertTrue((actual == 4).all())
def test_large_strided_reduction(self):
# Test 64-bit indexing is used when input numel is less than INT_MAX
# but stride calculations go above INT_MAX
if not _has_sufficient_memory(self.device, 2**31 + 2):
raise unittest.SkipTest("insufficient memory")
def fn(a):
return torch.max(a)
storage = torch.ones(2**31 + 1, dtype=torch.int8, device=self.device)
view = storage[::32]
view[-1] = 2
compiled_fn = torch._dynamo.optimize()(fn)
actual = compiled_fn(view)
expect = torch.tensor(2, dtype=torch.int8, device=self.device)
self.assertEqual(actual, expect)
def test_softmax(self):
def fn(a, b):
return (torch.softmax(a + b, -1), torch.softmax(a, 0), torch.softmax(b, 1))
self.common(fn, (torch.randn(8, 8), torch.randn(8, 8)))
def test_log_softmax(self):
def fn(a, b):
return (F.log_softmax(a + b, -1), F.log_softmax(a, 0), F.log_softmax(b, 1))
self.common(fn, (torch.randn(8, 8), torch.randn(8, 8)))
def test_transpose(self):
def fn(a, b):
return (
torch.t(a) + b,
torch.transpose(b * 2, 0, 1) + 10,
)
self.common(fn, (torch.randn(8, 8), torch.randn(8, 8)))
def test_permute1(self):
def fn(a):
return (
torch.permute(a + 1, [2, 1, 4, 0, 3]) + 2,
torch.permute(a, [2, 1, 4, 0, 3]) + 2,
)
self.common(fn, (torch.randn(2, 2, 2, 2, 2),))
def test_permute2(self):
def fn(a):
a = a.unfold(0, 2, 1)
a = torch.unsqueeze(a, 1)
a = torch.permute(a, [0, 2, 3, -3])
return (a,)
self.common(fn, (torch.randn(4, 4),))
def test_expand(self):
def fn(a):
return (
(a + 1).expand(3, 4, 2, 3, 2) + 2,
a.expand(2, 1, 2, 3, 2) + 2,
), a.expand(2, -1, 5, -1)
self.common(fn, (torch.randn(2, 1, 2),))
def test_squeeze1(self):
def fn(a):
return ((a + 1).squeeze() + 2, a.squeeze() + 2)
self.common(fn, (torch.randn(1, 2, 1, 2, 2, 1, 1),))
def test_squeeze2(self):
def fn(a):
return ((a + 1).squeeze(-1).squeeze(2) + 2, a.squeeze(0) + 2)
self.common(fn, (torch.randn(1, 2, 1, 2, 2, 2, 1),))
def test_simplify_loops(self):
def fn(a, b):
return a + b
self.common(
fn,
(
torch.randn(2, 3, 4, 5, 6),
torch.randn(4, 2, 3, 5, 6).permute(1, 2, 0, 3, 4),
),
)
def test_unsqueeze(self):
def fn(a):
return (
torch.unsqueeze(a + 1, -1) + 2,
torch.unsqueeze(a, 2) + 2,
torch.unsqueeze(a + 1, 0) + 2,
torch.unsqueeze(a, -2) + 2,
)
self.common(
fn,
(
torch.randn(
2,
2,
2,
2,
),
),
)
def test_unsqueeze_inplace(self):
def fn(a):
tmp1 = a + 1
aten.unsqueeze_(tmp1, 2)
tmp2 = aten.unsqueeze_(a + 1, 0) + 2
return (tmp1, tmp2)
self.common(
fn,
(
torch.randn(
2,
2,
2,
2,
),
),
)
def test_addmm(self):
def fn(a, b, c):
return (torch.addmm(a + 1, b + 2, c + 3) + 4,)
self.common(
fn,
(
torch.randn(8, 8),
torch.randn(8, 8),
torch.randn(8, 8),
),
)
# https://github.com/pytorch/pytorch/issues/98979
@unittest.skipIf(HAS_CUDA, "cuda failed for float64 linear")
def test_linear_float64(self):
mod = torch.nn.Sequential(torch.nn.Linear(8, 16).to(torch.float64)).eval()
with torch.no_grad():
self.common(mod, (torch.randn(2, 8).to(torch.float64),))
def test_linear1(self):
mod = torch.nn.Sequential(
torch.nn.Linear(8, 16),
torch.nn.Sigmoid(),
ToTuple(),
)
self.common(mod, (torch.randn(2, 8),))
def test_linear2(self):
mod = torch.nn.Sequential(
torch.nn.Linear(8, 8),
torch.nn.ReLU(),
torch.nn.Linear(8, 8),
torch.nn.ReLU(),
torch.nn.Linear(8, 8),
torch.nn.ReLU(),
torch.nn.Linear(8, 8),
torch.nn.ReLU(),
)
self.common(mod, (torch.randn(2, 8),))
def test_bmm1(self):
def fn(a, b):
return (
torch.bmm(a, b),
torch.bmm(a + 1, b + 2) + 3,
)
self.common(
fn,
(
torch.randn(2, 8, 8),
torch.randn(2, 8, 8),
),
check_lowp=False,
)
self.common(
fn,
(
torch.randn(1, 16, 8),
torch.randn(1, 8, 10),
),
check_lowp=False,
)
def test_bmm2(self):
def fn(a, b):
return torch.bmm(a.permute(0, 2, 1), b)
self.common(
fn,
(
torch.randn(1, 8, 8),
torch.randn(1, 8, 8),
),
check_lowp=False,
)
def test_scalar_input(self):
def fn(x, y):
a = torch.div(x, y, rounding_mode="floor")
return a
self.common(fn, [torch.randint(5, (1, 8)), 5400])
def test_shape_prop_torch_ones(self):
class Model(torch.nn.Module):
def forward(self, attention_scores):
extended_attention_mask = torch.ones(
8, 1, 1, 512, device=attention_scores.device
)
attention_scores = attention_scores + extended_attention_mask
return attention_scores
mod = Model().eval()
with torch.no_grad():
self.common(
mod,
(torch.randn(8, 12, 512, 512),),
)
@slowTest
def test_conv_bn_fuse(self):
# For gpu path, there is an accuracy issue
if self.device == "cuda":
raise unittest.SkipTest("only support cpu conv bn test")
input_shapes = {1: (112,), 2: (112, 112), 3: (55, 55, 55)}
conv_modules = {1: torch.nn.Conv1d, 2: torch.nn.Conv2d, 3: torch.nn.Conv3d}
bn_modules = {
1: torch.nn.BatchNorm1d,
2: torch.nn.BatchNorm2d,
3: torch.nn.BatchNorm3d,
}
options = itertools.product(
[1, 2, 3],
[True, False],
[1, 3],
[1, 2],
[1, 4],
)
for (
dim,
bias,
kernel_size,
dilation,
groups,
) in options:
oC = 32 * groups
iC = 3 * groups
x_shape = (1, iC) + input_shapes[dim]
mod = torch.nn.Sequential(
conv_modules[dim](
iC,
oC,
kernel_size=kernel_size,
dilation=dilation,
groups=groups,
bias=bias,
),
bn_modules[dim](oC),
).eval()
test_memory_format = [torch.contiguous_format]
# TODO: GPU path doesn't support channels_last now.
if not HAS_CUDA and dim > 1:
channels_last = (
torch.channels_last if dim == 2 else torch.channels_last_3d
)
test_memory_format.append(channels_last)
for memory_format in test_memory_format:
v = torch.randn(x_shape, dtype=torch.float32).to(
memory_format=memory_format
)
with torch.no_grad():
self.common(
mod,
(v,),
)
def test_conv_functional_bn_fuse(self):
# For gpu path, there is an accuracy issue
if self.device == "cuda":
raise unittest.SkipTest("only support cpu conv bn test")
# Define a BatchNorm using functional BN.
class BatchNorm(torch.nn.BatchNorm2d):
def __init__(
self,
num_features,
eps=1e-5,
momentum=0.1,
affine=True,
track_running_stats=True,
device=None,
dtype=None,
):
factory_kwargs = {"device": device, "dtype": dtype}
super().__init__(
num_features,
eps=eps,
momentum=momentum,
affine=affine,
track_running_stats=track_running_stats,
**factory_kwargs,
)
def forward(self, x):
if self.momentum is None:
exponential_average_factor = 0.0
else:
exponential_average_factor = self.momentum
if self.training and self.track_running_stats:
# TODO: if statement only here to tell the jit to skip emitting this when it is None
if self.num_batches_tracked is not None: # type: ignore[has-type]
self.num_batches_tracked = self.num_batches_tracked + 1 # type: ignore[has-type]
if self.momentum is None: # use cumulative moving average
exponential_average_factor = 1.0 / float(
self.num_batches_tracked
)
else: # use exponential moving average
exponential_average_factor = self.momentum
if self.training:
bn_training = True
else:
bn_training = (self.running_mean is None) and (
self.running_var is None
)
x = F.batch_norm(
x,
# If buffers are not to be tracked, ensure that they won't be updated
self.running_mean
if not self.training or self.track_running_stats
else None,
self.running_var
if not self.training or self.track_running_stats
else None,
self.weight,
self.bias,
bn_training,
exponential_average_factor,
self.eps,
)
return x
v = torch.randn(1, 3, 556, 56, dtype=torch.float32)
mod = torch.nn.Sequential(
torch.nn.Conv2d(
3,
64,
kernel_size=3,
dilation=1,
groups=1,
bias=True,
),
BatchNorm(64),
).eval()
with torch.no_grad():
self.common(
mod,
(v,),
)
def test_upsample_cat_conv(self):
if self.device == "cuda":
raise unittest.SkipTest("only support cpu upsample_cat_conv test")
class M(torch.nn.Module):
def __init__(
self,
**kwargs,
):
super().__init__()
self.upsample = torch.nn.UpsamplingNearest2d(scale_factor=2)
self.conv = torch.nn.Conv2d(
8,
5,
kernel_size=1,
padding=0,
stride=1,
dilation=1,
**kwargs,
)
def forward(self, x, y):
x = self.upsample(x)
z = torch.cat([x, y], dim=1)
z = self.conv(z)
return z
v1 = torch.randn([8, 2, 12, 26])
v2 = torch.randn([8, 6, 24, 52])
with torch.no_grad():
self.common(
M().eval(),
(v1, v2),
)
def test_aliased_buffer_reuse(self):
def fn(x, y):
x = 2 * x
y = 2 * y
c = torch.cat([x, y], dim=-1)
d = 1 + c
m = torch.mm(d, d)
return m[:, :2] + x
self.common(fn, (torch.randn(4, 2), torch.randn(4, 2)), check_lowp=False)
def test_view_detach(self):
def fn(a):
return a[0].detach()
self.common(
fn,
(torch.randn([4, 4], requires_grad=True),),
)
def test_gather1(self):
def fn(a, b):
return (
torch.gather(a.expand([4, 5, 10, 6]), 3, b + 1),
torch.gather(a.expand([4, 5, 10, 6]), -1, b + 1),
)
self.common(
fn,
(
torch.randn([1, 1, 10, 6]),
torch.randint(5, [4, 5, 10, 1], dtype=torch.int64),
),
)
def test_gather2(self):
# 0d tensor
def fn(a, b):
return torch.gather(a, 0, b) + torch.gather(a, -1, b)
x = torch.tensor(123)
y = torch.tensor(0)
self.assertEqual(fn(x, y), x + x)
def test_gather3(self):
def fn(a, b):
return torch.gather(a, 1, b, sparse_grad=True)
self.common(
fn,
(
torch.randn([4, 5, 10, 6], requires_grad=True),
torch.randint(5, [4, 5, 10, 1], dtype=torch.int64),
),
)
def test_slice1(self):
def fn(a):
return (
a[:, :10, 0] + a[:, 10:, 0],
(a + 1)[:, :10, 0] + (a + 1)[:, 10:, 0],
a[:, -30:, 0], # negative index out of range
a[:, :-30, 0], # negative index out of range
)
self.common(
fn,
(torch.randn([2, 20, 2]),),
)
def test_slice2(self):
def fn(a):
return (
a[:-1, ::2, -1] + a[-1:, 1::2, -2],
(a + 1)[:-1, ::2, -1] + (a + 2)[-1:, 1::2, -2],
)
self.common(
fn,
(torch.randn([2, 20, 2]),),
)
def test_split_with_sizes(self):
def fn(a, sizes):
return [t + 1.0 for t in torch.split(a * 2.0, sizes, -1)]
self.common(fn, (torch.randn(2, 2, 10), [3, 3, 4]))
self.common(fn, (torch.randn(2, 2, 10), [4, 3, 3]))
self.common(fn, (torch.randn(2, 2, 10), [1, 2, 3, 4]))
def test_split_with_sizes_failed(self):
@torch._dynamo.optimize("inductor")
def fn(a):
return torch.split(a, [2, 1, 1], dim=1)
with self.assertRaisesRegex(RuntimeError, ""):
fn(torch.randn(1, 5))
def test_inductor_assert(self):
@torch._dynamo.optimize("inductor", dynamic=True)
def fn(a):
assert a.shape[0] >= 2 and a.shape[1] >= 4
return a.cos()
inp = torch.randn(2, 4, 6)
torch._dynamo.mark_dynamic(inp, 0)
torch._dynamo.mark_dynamic(inp, 1)
self.assertEqual(fn(inp), inp.cos())
def test_split(self):
def fn(a):
t = torch.split(a, 3, -1)
return (t[0], t[1], t[2], t[3])
def fn2(a):
return fn(a + 1)
self.common(
fn,
(torch.randn([2, 2, 10]),),
)
self.common(
fn2,
(torch.randn([2, 2, 10]),),
)
def test_to_dtype(self):
def fn(a, b):
return (
aten._to_copy(a, dtype=6),
aten._to_copy(b + 1, dtype=6),
aten.to(b, torch.float64),
aten.to(b, torch.bool),
)
self.common(
fn,
(
torch.randn([2, 2, 10]),
torch.randn([2, 2, 10], dtype=torch.float64),
),
)
@requires_cuda()
def test_to_device(self):
def fn(a):
if a.device.type == "cpu":
return aten._to_copy(a, device=torch.device("cuda"), dtype=6, layout=0)
else:
return aten._to_copy(a, device=torch.device("cpu"), dtype=6, layout=0)
self.common(
fn,
(torch.randn([2, 2, 10]),),
)
def test_to_memory_format(self):
def fn(a, memory_format):
return a.to(memory_format=memory_format)
self.common(
fn,
(torch.randn([2, 2, 10, 10]), torch.channels_last),
)
self.common(
fn,
(
torch.randn([2, 2, 10, 10]).to(memory_format=torch.channels_last),
torch.contiguous_format,
),
)
@requires_cuda()
def test_to_device_constant(self):
def fn(a):
d1 = a.device.type
if d1 == "cpu":
d2 = "cuda"
else:
d2 = "cpu"
const1 = torch.as_tensor(list(range(64)), device=d2)
return (
torch.arange(10, device=d2).to(d1) + a,
const1.to(d1),
(const1 + 1).to(d1),
)
self.common(
fn,
(torch.randn([10]),),
)
@requires_cuda()
def test_multi_device(self):
def fn(x):
x = x + 1
x = x + 2
x = x.cuda()
x = x + 3
x = x + 4
x = x.cpu()
x = x + 5
x = x + 6
x = x.cuda()
x = x + 7
x = x + 8
x = x.cpu()
x = x + 9
x = x + 10
return x
self.common(
fn,
(torch.randn([2, 2, 10]),),
check_lowp=False, # cpu doesn't understand fp16, and there are explicit .cpu() calls
)
@requires_multigpu()
def test_multi_gpu_device(self):
# TODO: https://github.com/pytorch/pytorch/issues/92627
x = torch.rand([4], device="cuda")
def fn(x, y):
r = torch.ops.aten.div(x, y)
r = r.to("cuda:1")
return 2 * r
self.common(fn, (torch.randn(4), torch.randn(4)), check_lowp=False)
@skipIfRocm
@requires_multigpu()
def test_multi_gpu_recompile_on_index(self):
torch.set_float32_matmul_precision("high")
def gemm(x, y):
return x @ y
failed_guard = None
def fail(guard):
nonlocal failed_guard
failed_guard = guard
gemm_opt = torch._dynamo.optimize("inductor", guard_fail_fn=fail)(gemm)
x0 = torch.randn(1024, 1024, device="cuda:0")
y0 = torch.randn(1024, 1024, device="cuda:0")
gemm_opt(x0, y0)
x1 = torch.randn(1024, 1024, device="cuda:1")
y1 = torch.randn(1024, 1024, device="cuda:1")
gemm_opt(x1, y1)
self.assertTrue(failed_guard is not None)
self.assertTrue(
"tensor 'L['x']' Tensor device index mismatch. Expected device index to be"
in failed_guard.reason
)
def test_unbind(self):
def fn(a):
return torch.unbind(a), torch.unbind(a, -1)
self.common(
fn,
(torch.randn([4, 4, 4]),),
)
@skipIfRocm
def test_convolution1(self):
m = torch.nn.Sequential(
torch.nn.Conv2d(5, 6, [3, 3]),
torch.nn.ReLU(),
ToTuple(),
)
self.common(
m,
(torch.randn([2, 5, 16, 16]),),
# Mismatched elements: 10 / 2352 (0.4%)
# Greatest absolute difference: 5.7220458984375e-05 at index (0, 3, 12, 12) (up to 1e-05 allowed)
# Greatest relative difference: 0.06512477175897748 at index (0, 4, 11, 9) (up to 0.001 allowed)
atol=6e-5,
rtol=0.001,
)
def test_convolution2(self):
def fn(x, w, b):
# transposed conv
return (aten.convolution(x, w, b, [4], [0], [1], True, [0], 1),)
self.common(
fn,
(
torch.randn([2, 32, 90]),
torch.randn([32, 16, 8]),
torch.randn([16]),
),
check_lowp=False,
)
@skipIfRocm
def test_convolution3(self):
# Test stride or padding or dilation is 1 element list.
m = torch.nn.Sequential(
torch.nn.Conv2d(5, 6, [3, 3], stride=[1], padding=[0], dilation=[1]),
torch.nn.ReLU(),
ToTuple(),
)
self.common(
m,
(torch.randn([2, 5, 16, 16]),),
atol=6e-5,
rtol=0.001,
)
def test_conv2d_channels_last(self):
if self.device == "cuda":
raise unittest.SkipTest("only support cpu conv2d channels_last")
m = torch.nn.Sequential(
torch.nn.Conv2d(3, 3, 1, 1),
ToTuple(),
)
# only weight is channels_last
self.common(
m.to(memory_format=torch.channels_last),
(torch.randn([2, 3, 16, 16]),),
check_lowp=False,
)
# only activation is channels_last
self.common(
m,
(torch.randn([2, 3, 16, 16]).to(memory_format=torch.channels_last),),
check_lowp=False,
)
# activation and weight are all channels_last
self.common(
m.to(memory_format=torch.channels_last),
(torch.randn([2, 3, 16, 16]).to(memory_format=torch.channels_last),),
check_lowp=False,
)
def test_conv2d_backward_channels_last(self):
def fn(grad_output, inp, weight):
convolution_backward_8 = torch.ops.aten.convolution_backward.default(
grad_output,
inp,
weight,
[320],
[1, 1],
[0, 0],
[1, 1],
False,
[0, 0],
1,
[True, True, True],
)
return convolution_backward_8
# only weight is channels_last
self.common(
fn,
(
torch.randn([2, 320, 8, 8]),
torch.randn([2, 2048, 8, 8]),
torch.randn([320, 2048, 1, 1]).to(memory_format=torch.channels_last),
),
check_lowp=False,
)
def test_conv3d_channels_last(self):
if self.device == "cuda":
raise unittest.SkipTest("only support cpu conv3d channels_last")
m = torch.nn.Sequential(
torch.nn.Conv3d(3, 3, 1, 1),
ToTuple(),
)
# only weight is channels_last
self.common(
m.to(memory_format=torch.channels_last_3d),
(torch.randn([2, 3, 16, 16, 16]),),
)
# only activation is channels_last
self.common(
m,
(torch.randn([2, 3, 16, 16, 16]).to(memory_format=torch.channels_last_3d),),
)
# activation and weight are all channels_last
self.common(
m.to(memory_format=torch.channels_last_3d),
(torch.randn([2, 3, 16, 16, 16]).to(memory_format=torch.channels_last_3d),),
)
def test_adaptive_avg_pool2d1(self):
def fn(x):
return aten._adaptive_avg_pool2d(x, (6, 6)), aten._adaptive_avg_pool2d(
x + 1, (2, 5)
)
self.common(
fn,
(torch.randn(2, 4, 16, 16),),
check_lowp=False,
)
# lowering to avg_pool2d case
self.common(
fn,
(torch.randn(2, 4, 3, 3),),
)
# no-op case
self.common(
fn,
(torch.randn(2, 4, 6, 6),),
)
def test_adaptive_avg_pool2d2(self):
# Big kernel size, use fallback
def fn(x):
return aten._adaptive_avg_pool2d(x, (4, 4))
torch._inductor.metrics.generated_kernel_count = 0
self.common(
fn,
(torch.randn(2, 4, 21, 21),),
check_lowp=False,
)
self.assertEqual(torch._inductor.metrics.generated_kernel_count, 0)
def test_adaptive_avg_pool2d_low_prec(self):
class Model(torch.nn.Module):
def __init__(self):
super(Model, self).__init__()
self.avgpool = torch.nn.AdaptiveAvgPool2d((1, 1))
def forward(self, x):
x = self.avgpool(x)
return x
mod = Model()
for dtype in [torch.half, torch.bfloat16]:
x = torch.randn(4, 3, 7, 7).to(dtype=dtype)
opt_mod = torch.compile(mod)
res = opt_mod(x)
expected = mod(x)
self.assertTrue(torch.allclose(res, expected))
def test_max_pool2d1(self):
def fn(x):
return aten.max_pool2d_with_indices(x, [3, 3], [2, 2])
self.common(
fn,
(torch.randn(2, 4, 16, 16),),
)
def test_max_pool2d2(self):
def fn(x):
return aten.max_pool2d_with_indices(x, [3, 3], [2, 2])
self.common(
fn,
(torch.randn([16, 64, 55, 55]),),
)
def test_max_pool2d3(self):
def fn(x):
# with padding
return (
aten.max_pool2d_with_indices(x, [3, 3], [2, 2], [1, 1]),
aten.max_pool2d_with_indices(
x,
[
3,
],
[
2,
],
[
1,
],
),
)
self.common(
fn,
(-torch.arange(1 * 8 * 8, dtype=torch.float32).view(1, 1, 8, 8),),
)
def test_max_pool2d4(self):
def fn(x):
# with padding
return aten.max_pool2d_with_indices(x, [3, 3], [2, 2], [0, 0], [1, 1], True)
self.common(
fn,
(torch.randn([2, 8, 111, 111]),),
)
def test_max_pool2d5(self):
def fn(x):
return aten.max_pool2d_with_indices(x, [3, 3], [])
self.common(
fn,
(torch.randn([16, 64, 55, 55]),),
)
def test_max_pool2d6(self):
# Too big kernel size, use fallback
def fn(x):
return aten.max_pool2d_with_indices(x, [13, 13], [])
torch._inductor.metrics.generated_kernel_count = 0
self.common(
fn,
(torch.randn([16, 64, 55, 55]),),
)
self.assertEqual(torch._inductor.metrics.generated_kernel_count, 0)
# From https://github.com/pytorch/pytorch/issues/94775
def test_max_pool2d7(self):
# ceil mode turns on
def fn(x):
return torch.nn.functional.max_pool2d(
x, 1, stride=(2, 2), padding=0, ceil_mode=True
)
self.common(
fn,
(torch.randn([1, 1, 6, 7]),),
)
# From https://github.com/pytorch/pytorch/issues/93384
def test_max_pool2d8(self):
# dialtion is not 1, use fallback
def fn(x):
return aten.max_pool2d_with_indices(x, [3, 2], [2, 1], [1, 1], [1, 2])
torch._inductor.metrics.generated_kernel_count = 0
self.common(
fn,
(torch.randn([2, 2, 3, 6]),),
)
self.assertEqual(torch._inductor.metrics.generated_kernel_count, 0)
def test_avg_pool2d1(self):
def fn(x):
return aten.avg_pool2d(x, [3, 3], [2, 2])
self.common(
fn,
(torch.randn(2, 4, 16, 16),),
)
def test_avg_pool2d2(self):
def fn(x):
return aten.avg_pool2d(x, [3, 3], [2, 2])
self.common(
fn,
(torch.randn([16, 64, 55, 55]),),
)
def test_avg_pool2d3(self):
def fn(x):
return (
aten.avg_pool2d(x, [3, 3], [2, 2], [1, 1]),
aten.avg_pool2d(
x,
[
3,
],
[
2,
],
[
1,
],
),
)
self.common(
fn,
(-torch.arange(1 * 8 * 8, dtype=torch.float32).view(1, 1, 8, 8),),
)
def test_avg_pool2d4(self):
def fn(x):
return aten.avg_pool2d(x, [3, 3], [2, 2], [0, 0], True)
self.common(
fn,
(torch.randn([2, 8, 111, 111]),),
)
def test_avg_pool2d5(self):
def fn(x):
return aten.avg_pool2d(x, [3, 3], [2, 2], [1, 1], count_include_pad=False)
self.common(
fn,
(-torch.arange(1 * 8 * 8, dtype=torch.float32).view(1, 1, 8, 8),),
)
def test_avg_pool2d6(self):
def fn(x):
return aten.avg_pool2d(x, [3, 3], [2, 2], [1, 1], divisor_override=3)
self.common(
fn,
(-torch.arange(1 * 8 * 8, dtype=torch.float32).view(1, 1, 8, 8),),
)
def test_avg_pool2d7(self):
# Large kernel size, use fallback
def fn(x):
return aten.avg_pool2d(x, [13, 13], [1, 1], [0, 0])
torch._inductor.metrics.generated_kernel_count = 0
self.common(
fn,
(-torch.arange(1 * 24 * 24, dtype=torch.float32).view(1, 1, 24, 24),),
)
self.assertEqual(torch._inductor.metrics.generated_kernel_count, 0)
def test_avg_pool2d8(self):
# https://github.com/pytorch/pytorch/issues/100987
def fn(x):
return aten.avg_pool2d(
x, kernel_size=3, stride=2, padding=1, ceil_mode=True
)
self.common(
fn,
(torch.randn(1, 3, 6, 6),),
)
def test_alexnet_prefix(self):
def forward(arg6, arg7, arg16):
convolution = torch.ops.aten.convolution(
arg16, arg7, arg6, [4, 4], [2, 2], [1, 1], False, [0, 0], 1
)
relu = torch.ops.aten.relu(convolution)
max_pool2d_with_indices = torch.ops.aten.max_pool2d_with_indices(
relu, [3, 3], [2, 2]
)
getitem = max_pool2d_with_indices[0]
return (getitem,)
self.common(
forward,
(
rand_strided((64,), (1,), torch.float32, "cpu"),
rand_strided((64, 3, 11, 11), (363, 121, 11, 1), torch.float32, "cpu"),
rand_strided(
(16, 3, 224, 224), (150528, 50176, 224, 1), torch.float32, "cpu"
),
),
# Mismatched elements: 127 / 746496 (0.0%)
# Greatest absolute difference: 0.0009765625 at index (1, 62, 7, 16) (up to 1e-05 allowed)
# Greatest relative difference: 0.05187467899332306 at index (14, 18, 11, 0) (up to 0.001 allowed)
atol=1e-3,
rtol=0.001,
)
def test_elu(self):
def fn(x):
return aten.elu(x, 1.6732632423543772, 1.0507009873554805) + 2, aten.elu(
x + 1, 2, 3, 4
)
self.common(
fn,
(torch.randn([16, 16]),),
)
def test_tan(self):
def fn(x):
return aten.tan(x) + 2, aten.tan(x + 1)
self.common(
fn,
(torch.randn([16, 16]),),
)
def test_tanh(self):
def fn(x):
return aten.tanh(x) + 2, aten.tanh(x + 1)
self.common(
fn,
(torch.randn([16, 16]),),
)
def test_lgamma(self):
def fn(x):
return aten.lgamma(x) + 2, aten.cos(x + 1)
self.common(
fn,
(torch.randn([16, 16]),),
)
def test_cos(self):
def fn(x):
return aten.cos(x) + 2, aten.cos(x + 1)
self.common(
fn,
(torch.randn([16, 16]),),
)
def test_sin(self):
def fn(x):
return aten.sin(x) + 2, aten.sin(x + 1)
self.common(
fn,
(torch.randn([16, 16]),),
)
def test_repeat(self):
def fn(x):
return (
x.repeat(2, 2, 3, 1),
x.repeat(8, 1, 1, 1),
x.repeat(2, 1, 1, 1, 1, 1),
)
self.common(
fn,
(torch.randn([1, 2, 4, 8]),),
)
def test_repeat_interleave(self):
def fn(x):
return (
x.repeat_interleave(2),
x.repeat_interleave(3, dim=0),
x.repeat_interleave(x.size(1), dim=1),
)
self.common(
fn,
(torch.randn([1, 2, 4, 8]),),
)
def test_embedding(self):
m = torch.nn.Sequential(
torch.nn.Embedding(10, 4, padding_idx=0),
torch.nn.ReLU(),
ToTuple(),
)
self.common(
m,
(torch.randint(10, [2, 8]),),
)
def test_mean(self):
def fn(x):
return (
x.mean(),
x.mean(-1),
torch.mean(x, -2, keepdim=True),
x.mean([0, 1]),
)
self.common(
fn,
(torch.randn([1, 2, 4, 8]),),
)
def test_var_mean(self):
def fn(x):
return (
*torch.var_mean(x, -1),
*torch.var_mean(x, [1, 3]),
)
self.common(
fn,
(torch.randn([1, 2, 4, 8]),),
)
@config.patch(pick_loop_orders=True)
def test_transposed_propagates(self):
@torch._dynamo.optimize("inductor", nopython=True)
def fn(x, y):
return x + y
a = torch.randn(1, 4, 4, 4, device=self.device).permute(0, 2, 3, 1)
b = torch.randn(4, 4, 4, device=self.device).permute(1, 2, 0)
c = fn(a, b)
self.assertEqual(a.stride(), c.stride())
self.assertEqual(c.stride()[2], 1)
def test_std(self):
def fn(x):
return (
torch.var(x, True),
torch.var(x, False),
torch.var(x, -1, True),
torch.var(x, -1, False),
torch.std(x, False),
torch.std(x, [0, 1], True),
torch.std(x, [0, 1], False),
torch.std(x, -2, True, keepdim=True),
)
self.common(
fn,
(torch.randn([2, 4, 4, 8]),),
)
def test_embedding_bag(self):
def fn(w, i, o):
return aten._embedding_bag(w, i, o, False, 0, False, None)
self.common(
fn,
(torch.randn([10, 4]), torch.randint(10, [8]), torch.tensor([0, 2, 6])),
)
def test_batch_norm_2d(self):
m = torch.nn.Sequential(
torch.nn.BatchNorm2d(10),
torch.nn.ReLU(),
)
m.eval()
self.common(m, (torch.randn([2, 10, 8, 8]),), check_lowp=False)
self.common(
m,
(torch.randn([3, 10, 16, 16]),),
check_lowp=False, # too painful to match types of bn model
)
def test_layer_norm(self):
m = torch.nn.Sequential(
torch.nn.LayerNorm(32),
torch.nn.ReLU(),
)
m.eval()
self.common(m, (torch.randn([16, 32]),), check_lowp=False)
if self.device != "cpu":
self.assertEqual(torch._inductor.metrics.generated_kernel_count, 1)
def test_transpose_add(self):
def fn(a, b):
return a.t() + b
self.common(
fn, (torch.randn([16, 32]), torch.randn([32, 16])), check_lowp=False
)
if self.device != "cpu":
self.assertEqual(torch._inductor.metrics.generated_kernel_count, 1)
@patch.object(config.triton, "persistent_reductions", True)
def test_softmax_one_kernel_persist(self):
def fn(x):
dim = 1
x_max = torch.amax(x, dim, keepdim=True)
unnormalized = torch.exp(x - x_max)
result = unnormalized / torch.sum(unnormalized, dim, keepdim=True)
return result
self.common(fn, (torch.randn([16, 32]),), check_lowp=False)
if self.device != "cpu":
self.assertEqual(torch._inductor.metrics.generated_kernel_count, 1)
@patch.object(config.triton, "persistent_reductions", False)
def test_softmax_one_kernel_loop(self):
def fn(x):
x_max = torch.amax(x, 1, keepdim=True)
unnormalized = torch.exp(x - x_max)
result = unnormalized / torch.sum(unnormalized, 1, keepdim=True)
return result
self.common(fn, (torch.randn([16, 32]),), check_lowp=False)
if self.device != "cpu":
self.assertEqual(torch._inductor.metrics.generated_kernel_count, 1)
def test_complex_fallback(self):
def fn(x):
return x * x + 10
self.common(
fn,
(torch.randn([1, 2, 4, 8]).to(dtype=torch.complex64),),
)
self.assertEqual(torch._inductor.metrics.generated_kernel_count, 0)
class ToComplex(nn.Module):
def forward(self, x):
return (x + x + 12).to(torch.complex64)
self.common(ToComplex(), (torch.rand([1, 2, 4, 8]),), check_lowp=False)
if self.device != "cpu":
self.assertEqual(torch._inductor.metrics.generated_kernel_count, 1)
def test_view_as_complex(self):
class Repro(torch.nn.Module):
def __init__(self):
super().__init__()
def forward(self, view_2):
clone = torch.ops.aten.clone.default(
view_2, memory_format=torch.contiguous_format
)
view_2 = None
view_as_complex = torch.ops.aten.view_as_complex.default(clone)
clone = None
return (view_as_complex,)
inp = torch.empty_strided((128, 64, 12, 32, 2), (1, 98304, 8192, 256, 128)).to(
self.device
)
mod = Repro()
o1 = mod(inp)
o2 = torch.compile(mod)(inp)
self.assertEqual(o1, o2)
def test_cauchy(self):
def fn(x, y):
return torch.sum(1 / (torch.unsqueeze(x, -1) - y))
self.common(
fn,
(
torch.randn(32),
torch.randn(32),
),
# Absolute difference: 0.0003662109375 (up to 0.0001 allowed)
# Relative difference: 1.8804297408767818e-05 (up to 1e-05 allowed)
atol=5 * 1e-4,
rtol=5 * 1e-5,
check_lowp=False,
)
if self.device != "cpu":
self.assertEqual(torch._inductor.metrics.generated_kernel_count, 1)
def test_gather_scatter(self):
def fn(node_feat, edge_index):
src_node_feat = node_feat[edge_index[0]]
dst_node_feat = node_feat[edge_index[1]]
edge_feat = src_node_feat - dst_node_feat + 1
new_node_feat = torch.zeros_like(node_feat)
new_node_feat.scatter_add_(
0, edge_index[1].unsqueeze(-1).expand_as(edge_feat), edge_feat
)
return new_node_feat
num_nodes = 16
num_features = 32
node_feat = torch.randn(num_nodes, num_features)
edge_index = torch.randint(0, num_nodes, size=(2, num_nodes * 5))
self.common(
fn,
(
node_feat,
edge_index,
),
check_lowp=False,
)
if self.device != "cpu":
self.assertEqual(torch._inductor.metrics.generated_kernel_count, 2)
@config.patch(max_fusion_size=1)
def test_no_mega_fusion_during_lowering(self):
n = 50
def fn(*args):
x = args[0]
for i in range(n):
x = torch.add(x, args[i])
return x
self.common(
fn,
[torch.randn(64) for _ in range(n)],
check_lowp=False,
)
print("-->", torch._inductor.metrics.generated_kernel_count)
if self.device != "cpu":
self.assertTrue(torch._inductor.metrics.generated_kernel_count > 1)
def test_move_arange(self):
def fn(x):
return torch.arange(len(x), device="cpu").to(x.device) + x
self.common(fn, (torch.randn([32]),), check_lowp=False)
# if we have a copy there will be more than 1 kernel
self.assertEqual(torch._inductor.metrics.generated_kernel_count, 1)
def test_leaky_relu(self):
def fn(x):
return aten.leaky_relu(x, 0.2) + 2, aten.leaky_relu(x + 1)
self.common(
fn,
(torch.randn([16, 16]),),
)
def test_gelu(self):
def fn(x):
return aten.gelu(x) + 2, aten.gelu(x + 1)
self.common(
fn,
(torch.randn([16, 16]),),
)
def test_clone(self):
def fn(x):
return aten.clone(x) + 2, aten.clone(x + 1)
self.common(
fn,
(torch.randn([16, 16]),),
)
def test_masked_fill(self):
def fn(mask, value):
return aten.masked_fill(value, mask, -10000.0) + 2, aten.masked_fill(
value / 2.0, torch.logical_not(mask), 667
)
self.common(
fn,
(
torch.randint(0, 1, [1, 16], dtype=torch.bool),
torch.randn([16, 16]),
),
)
def test_masked_fill_promotion(self):
def fn(mask, value):
return aten.masked_fill(value, mask, torch.tensor(3.5))
opt_fn = torch._dynamo.optimize("inductor")(fn)
for inp in (
torch.randn(
[16, 16],
dtype=torch.float16 if self.device == "cuda" else torch.float32,
device=self.device,
),
torch.randint(16, (16, 16), device=self.device),
):
inputs = (
torch.randint(0, 1, [1, 16], dtype=torch.bool, device=self.device),
inp,
)
self.assertEqual(fn(*inputs), opt_fn(*inputs))
def test_fill1(self):
def fn(x):
tmp = torch.ones_like(x)
return tmp, aten.fill.Scalar(tmp, 2)
self.common(
fn,
(torch.randn([16, 16]),),
)
def test_fill2(self):
def fn(x):
tmp = torch.ones_like(x)
return tmp, aten.fill.Tensor(tmp, torch.tensor(3.0))
self.common(
fn,
(torch.randn([16, 16]),),
)
def test_pow1(self):
def fn(x):
return [aten.pow(x, e) for e in range(-8, 9)]
self.common(
fn,
(torch.randn([16, 16]),),
)
def test_pow2(self):
def fn(x):
return aten.pow(1000, x), aten.pow(x, 1000)
self.common(
fn,
# TODO: Remove dtype once https://github.com/pytorch/pytorch/issues/94010 is fixed
(
torch.randn(
[16, 16],
dtype=torch.float64 if self.device == "cpu" else torch.float32,
),
),
# Mismatched elements: 9 / 256 (3.5%)
# Greatest absolute difference: 2.491354329061828e+28 at index (6, 6) (up to 1e-05 allowed)
# Greatest relative difference: 2.9793410720160818e-05 at index (4, 5) (up to 1.3e-06 allowed)
atol=1e-5,
rtol=3e-05,
)
def test_pow3(self):
# power of 0.5 is special-cased, arbitrary power would still produce triton codegen error
def fn(x):
z = torch.tensor(0.123, device=self.device)
w = z + x
return torch.pow(w, 0.5)
opt = torch._dynamo.optimize("inductor")(fn)
input = torch.rand(())
self.assertTrue(same(opt(input), fn(input)))
def test_pow_int(self):
def fn(x, y):
return torch.pow(x, 0x57), torch.pow(x, y)
for dtype in (torch.uint8, torch.int8, torch.int16, torch.int32, torch.int64):
intmax = torch.iinfo(dtype).max
make_arg = functools.partial(
make_tensor, dtype=dtype, device="cpu", requires_grad=False
)
self.common(
fn,
(
make_arg(16, 16),
make_arg(16, 16, high=intmax),
),
)
def test_glu(self):
def fn(x):
return aten.glu(x, -1), aten.glu(x, 1), aten.glu(x, 2)
self.common(
fn,
(torch.randn([8, 16, 8, 8]),),
)
def test_cat(self):
def fn(a):
tmp = a * 2
return (
torch.cat((a, a[:, :4] + 1, a + 2), -1),
torch.cat((tmp, tmp), 0),
torch.cat((tmp, tmp.double()), 0),
)
self.common(
fn,
(torch.randn([8, 16]),),
)
self.common(
fn,
(torch.randn([1, 3, 3, 16]).to(memory_format=torch.channels_last),),
)
def test_cat_upcasting(self):
def fn(arg4_1, slice_7):
cat_1 = aten.cat.default([arg4_1, slice_7], 1)
return (cat_1,)
self.common(
fn,
(
torch.randn([8, 16], dtype=torch.float32),
torch.randn([8, 20], dtype=torch.float16),
),
)
def test_cat_extern_kernel(self):
def fn(x1, x2, x3, x4):
x = torch.mm(x2, x3)
s = torch.narrow(x, 1, 0, 100)
x = torch.mm(s, x4)
c = torch.cat((x, x1), 1)
return (c,)
self.common(
fn,
(
torch.randn(256, 256),
torch.randn(256, 1024),
torch.randn(1024, 1600),
torch.randn(100, 256),
),
check_lowp=False, # accuracy issues with relatively large matmuls
)
def test_cat_of_loops_and_extern_kernel(self):
class M(torch.nn.Module):
def __init__(
self,
**kwargs,
):
super().__init__()
self.conv = torch.nn.Conv2d(
64,
5,
1,
**kwargs,
)
self.max_pool2d = torch.nn.MaxPool2d(2)
def forward(self, x, y):
x1 = self.conv(x)
y1 = self.max_pool2d(y)
return torch.cat([x1, y1], 1)
mod = M()
opt_mod = torch._dynamo.optimize("inductor")(mod)
memory_format = torch.channels_last
inputs = (
torch.randn([1, 64, 16, 16]).to(memory_format=memory_format),
torch.randn([1, 64, 32, 32]).to(memory_format=memory_format),
)
y = mod(*inputs)
opt_y = opt_mod(*inputs)
self.assertEqual(y, opt_y)
self.assertEqual(y.stride(), opt_y.stride())
def test_cat_inplace(self):
def fn(x):
rt = torch.cat([x])
v = x.sin_()
return rt
# can't use self.common because input is modified inplace
inp = torch.ones(2)
opt_fn = torch.compile(fn)
res = opt_fn(inp.clone())
expected = fn(inp.clone())
self.assertEqual(res, expected)
def test_stack(self):
def fn(a, b):
return torch.stack(
[
a.expand(12, 16),
b.expand(12, 16),
],
2,
)
self.common(fn, (torch.randn([1, 16]), torch.randn([12, 1])))
def test_hardtanh(self):
def fn(x):
return F.hardtanh(x), F.hardtanh(x + 1), F.hardtanh(x - 1)
self.common(
fn,
(torch.randn([64]),),
)
def test_hardsigmoid(self):
def fn(x):
return F.hardsigmoid(x), F.hardsigmoid(x + 3), F.hardsigmoid(x - 3)
self.common(
fn,
(torch.randn([64]),),
)
def test_hardswish(self):
def fn(x):
return F.hardswish(x), F.hardswish(x + 3), F.hardswish(x - 3)
self.common(
fn,
(torch.randn([64]),),
)
def test_rsqrt(self):
def fn(x):
return torch.rsqrt(x), torch.rsqrt(x + 1) - 2
self.common(
fn,
(torch.randn([64]),),
)
def test_expm1(self):
def fn(x):
return torch.expm1(x), torch.expm1(x) * 2
for dtype in (torch.float16, torch.float, torch.double, torch.int, torch.int64):
self.common(
fn,
(torch.randn([64]).to(dtype=dtype),),
)
self.common(
fn,
(torch.arange(-1e-5, 1e-5, 1e-7).to(dtype=dtype),),
)
def test_log1p(self):
def fn(x):
return torch.log1p(x), torch.log1p(x) * 2
for dtype in (torch.float16, torch.float, torch.double, torch.int, torch.int64):
self.common(
fn,
(torch.randn([64]).to(dtype=dtype),),
)
self.common(
fn,
(torch.arange(-1e-5, 1e-5, 1e-7).to(dtype=dtype),),
)
def test_flip(self):
def fn(x):
return torch.flip(x, (-1,)), torch.flip(x, (0, 2)) - 2
self.common(
fn,
(torch.randn([1, 2, 6, 6]),),
)
def test_signbit(self):
def fn(x):
return torch.signbit(x), ~torch.signbit(-x) & 1
self.common(
fn,
(torch.randn([1, 2, 6, 6]),),
)
def test_sign_dtype(self):
def fn(x):
y = torch.sign(x)
return torch.tanh(y)
self.common(fn, (torch.randn([1, 2, 6, 6]),))
def test_fmod(self):
def fn(a, b):
return torch.fmod(a, b), torch.fmod(3.0 * a, b) - 2.0
shape = [1, 2, 6, 6]
self.common(fn, (torch.randn(shape), torch.randn(shape)))
def test_fmod_zero_dim(self):
def fn(a, b):
return (torch.fmod(a, b),)
self.common(
fn,
(
make_tensor(10, device="cpu", dtype=torch.float32),
make_tensor((), device="cpu", dtype=torch.float32),
),
)
self.common(
fn,
(
make_tensor((), device="cpu", dtype=torch.float32),
make_tensor(10, device="cpu", dtype=torch.float32),
),
)
def test_log2(self):
def fn(x):
return torch.log2(x), torch.log2(x + 1) - 2
self.common(
fn,
(torch.randn([64]) + 10,),
)
def test_logsumexp(self):
def fn(x):
return torch.logsumexp(x, -1), torch.logsumexp(x, 0) - 2
self.common(
fn,
(torch.randn([8, 8]) + 10,),
)
def test_log_fp64(self):
def fn(x):
return torch.log(x), torch.log2(x)
self.common(
fn,
(torch.randn([1024], dtype=torch.float64) + 10,),
)
def test_bitwise(self):
def fn(x, y):
return (
torch.bitwise_not(x),
torch.bitwise_or(x, y),
torch.bitwise_xor(x, y),
torch.bitwise_and(x, y),
)
self.common(
fn,
(
torch.randint(0, 2**30, [64], dtype=torch.int32),
torch.randint(0, 2**30, [64], dtype=torch.int32),
),
)
def test_bitwise2(self):
# again with bool types
def fn(x, y):
return (
torch.bitwise_not(x),
torch.bitwise_or(x, y),
torch.bitwise_xor(x, y),
torch.bitwise_and(x, y),
)
self.common(
fn,
(
torch.randint(0, 2, (2, 20), dtype=torch.bool),
torch.randint(0, 2, (2, 20), dtype=torch.bool),
),
)
def test_bitwise3(self):
# Repro for https://github.com/pytorch/pytorch/issues/97968
def fn(x, y):
return (
torch.max(torch.bitwise_and(x, y), y),
torch.clamp_max(torch.bitwise_or(x, y), y),
torch.clamp_min(torch.bitwise_xor(x, y), y),
)
self.common(
fn,
(
torch.rand([5, 10, 1]).to(torch.int8),
torch.rand([10, 1]).to(torch.int8),
),
)
def test_inf(self):
def fn(a):
return a + float("inf"), a + float("-inf"), a * -float("inf")
self.common(fn, (torch.randn(8),))
def test_remainder(self):
def fn(a, b):
return (
torch.remainder(a, b),
torch.remainder(a + 1, b - 1),
torch.remainder(a - 1, b + 1),
)
self.common(fn, (torch.randn(64), torch.randn(64)))
def test_zeros(self):
def fn(a):
return (
a + 1,
torch.zeros(
(1, 8, 64, 64),
dtype=torch.float32,
device=a.device,
),
torch.zeros(
1,
8,
64,
64,
dtype=torch.float32,
device=a.device,
),
torch.zeros(2, 3, names=None),
a + torch.ones(8, device=a.device),
torch.full((2, 3), 3.1416, device=a.device),
)
self.common(fn, (torch.randn(8),))
def test_new_ones(self):
def fn(a):
return (
aten.new_ones(
a, [], device=a.device, dtype=6, layout=0, pin_memory=False
),
aten.new_zeros(
a, [], device=a.device, dtype=6, layout=0, pin_memory=False
),
)
self.common(fn, (torch.randn(8),))
def test_full_like(self):
def fn(a):
return torch.full_like(a, 7.777) - 1
self.common(fn, (torch.randn(8),))
def test_full_truncation(self):
def fn(a):
return a + torch.full_like(a, 7.777)
for dtype in all_types():
self.common(fn, (make_tensor(8, dtype=dtype, device="cpu"),))
def test_index1(self):
def fn(a, b, c):
return aten.index(a, [b, c])
self.common(
fn,
(
torch.randn(8, 8, 12),
torch.tensor([0, 0, 2, 2], dtype=torch.int64),
torch.tensor([3, 4, 4, 3], dtype=torch.int64),
),
)
self.common(
fn,
(
torch.randn(8, 8, 12),
torch.tensor([[0, 0, 2, 2]], dtype=torch.int64),
torch.tensor([[3], [4], [4], [3]], dtype=torch.int64),
),
)
def test_index2(self):
def fn(a, b):
return (
aten.index(a, [b]),
aten.index(a, [None, b]),
)
self.common(
fn,
(
torch.randn(8, 8, 8),
torch.tensor([[0, 0, 2, 2]], dtype=torch.int64),
),
)
def test_index3(self):
def fn(x, ia, ib):
return (x[:, ia, None, ib, 0],)
self.common(
fn,
(
torch.randn(3, 4, 4, 4, 3),
torch.tensor([0, 2, 1], dtype=torch.int64),
torch.tensor([0, 2, 1], dtype=torch.int64),
),
)
def test_output_strides(self):
def fn(x):
y = x.permute(0, 2, 3, 1).contiguous()
torch._dynamo.graph_break()
return y.view(-1, 4)
inp = torch.rand([4, 4, 4, 4], device=self.device)
fn_opt = torch._dynamo.optimize("inductor")(fn)
self.assertEqual(fn(inp), fn_opt(inp))
self.assertEqual(fn(inp).stride(), fn_opt(inp).stride())
# no redundant copy
def foo(x):
return x[0:2:2].T[3:].squeeze(0)
foo_opt = torch._dynamo.optimize("inductor")(foo)
out = foo_opt(inp)
self.assertEqual(inp.storage(), out.storage())
def test_index_select(self):
def fn(a, b):
return (
torch.index_select(a, 0, b),
torch.index_select(a, 1, b),
torch.index_select(torch.index_select(a, 2, b), 1, b),
)
for ind_dtype in (torch.int32, torch.int64):
self.common(
fn,
(
torch.randn(8, 8, 8),
torch.tensor([0, 0, 2, 1], dtype=ind_dtype),
),
)
@skipIfRocm
def test_cudnn_rnn(self):
if self.device == "cpu":
raise unittest.SkipTest("requires CUDA")
def fn(
a0,
b0,
b1,
b2,
b3,
b4,
b5,
b6,
b7,
b8,
b9,
b10,
b11,
b12,
b13,
b14,
b15,
a3,
a4,
a5,
):
a1 = [
b0,
b1,
b2,
b3,
b4,
b5,
b6,
b7,
b8,
b9,
b10,
b11,
b12,
b13,
b14,
b15,
]
return aten._cudnn_rnn(
a0,
a1,
4,
a3,
a4,
a5,
2,
2048,
0,
2,
False,
0.0,
False,
True,
[],
None,
)
self.common(
fn,
(
torch.randn([92, 8, 2048]),
torch.randn([8192, 2048]),
torch.randn([8192, 2048]),
torch.randn([8192]),
torch.randn([8192]),
torch.randn([8192, 2048]),
torch.randn([8192, 2048]),
torch.randn([8192]),
torch.randn([8192]),
torch.randn([8192, 4096]),
torch.randn([8192, 2048]),
torch.randn([8192]),
torch.randn([8192]),
torch.randn([8192, 4096]),
torch.randn([8192, 2048]),
torch.randn([8192]),
torch.randn([8192]),
torch.randn([167837696]),
torch.randn([4, 8, 2048]),
torch.randn([4, 8, 2048]),
),
check_lowp=False, # difference in rnn is too large between half and float inputs
)
def test_upsample_nearest1d(self):
def fn(a):
return (
aten.upsample_nearest1d(a, [74], None),
aten.upsample_nearest1d(a, [70], None),
aten.upsample_nearest1d(a, [45], None),
aten.upsample_nearest1d(a, [36], None),
aten.upsample_nearest1d(a, None, [2.0]),
)
self.common(fn, (torch.randn([2, 4, 37]),))
def test_upsample_nearest2d(self):
def fn(a):
return (
aten.upsample_nearest2d(a, [74, 76]),
aten.upsample_nearest2d(a, [70, 75]),
aten.upsample_nearest2d(a, [45, 74]),
aten.upsample_nearest2d(a, [36, 39]),
aten.upsample_nearest2d(a, None, [2.0, 2.0]),
)
self.common(fn, (torch.randn([2, 4, 37, 38]),))
def test_upsample_nearest3d(self):
def fn(a):
return (
aten.upsample_nearest3d(a, [74, 76, 78], None),
aten.upsample_nearest3d(a, [70, 75, 80], None),
aten.upsample_nearest3d(a, [45, 74, 103], None),
aten.upsample_nearest3d(a, [36, 39, 40], None),
aten.upsample_nearest3d(a, None, [2.0, 2.0, 2.0]),
)
self.common(fn, (torch.randn([2, 4, 37, 38, 39]),))
def test_upsample_nearest2d_backward(self):
func = torch.ops.aten.upsample_nearest2d_backward
def fn(a):
return (
func(a, output_size=[6, 12], input_size=[3, 3, 3, 6]),
func(a, output_size=[6, 12], input_size=[3, 3, 4, 5]),
func(a, output_size=[6, 12], input_size=[3, 3, 2, 8]),
func(a, output_size=[6, 12], input_size=[3, 3, 2, 8]),
func(a, output_size=[6, 12], input_size=[3, 3, 4, 7]),
)
self.common(fn, (torch.randn([3, 3, 6, 12]),))
@skip_if_x86_mac()
def test_upsample_bilinear2d_a(self):
def fn(a):
return (
aten.upsample_bilinear2d(a, [45, 45], False, None),
aten.upsample_bilinear2d(a, None, True, [2.0, 2.0]),
)
self.common(fn, (torch.randn([2, 4, 37, 38]),), atol=2.5e-5, rtol=1.3e-6)
def test_upsample_bilinear2d_b(self):
def fn(a):
return aten.upsample_bilinear2d(a, None, True, [2.0, 2.0])
self.common(
fn,
[
torch.randn([1, 2, 40, 59]),
],
atol=2.5e-5,
rtol=1.3e-6,
)
def test_reflection_pad2d(self):
def fn(a):
return (
aten.reflection_pad2d(a, [1, 1, 1, 1]),
aten.reflection_pad2d(a, [1, 2, 3, 4]),
)
self.common(
fn, (torch.randint(0, 999, size=[1, 1, 8, 8], dtype=torch.float32),)
)
def test_reflection_pad2d_backward(self):
def template(size, padding):
def fn(grad_output, x):
return aten.reflection_pad2d_backward(grad_output, x, padding)
x = torch.randint(0, 999, size=size, dtype=torch.float32)
result = aten.reflection_pad2d(x, padding)
grad_output = torch.randn_like(result)
self.common(fn, (grad_output, x))
template([1, 1, 8, 8], [0, 0, 0, 0])
template([1, 1, 8, 8], [1, 1, 1, 1])
template([1, 1, 8, 8], [1, 2, 3, 4])
template([1, 1, 8, 8], [0, -1, 2, 2])
template([1, 1, 8, 8], [-1, 0, 2, 2])
template([1, 1, 8, 8], [2, 2, 0, -1])
template([1, 1, 8, 8], [2, 2, -1, 0])
def test_grid_sampler_2d(self):
def fn(a, b):
return (
aten.grid_sampler_2d(a, b, 0, 0, True),
aten.grid_sampler_2d(a, b, 0, 1, False),
)
self.common(
fn,
(
torch.randn([4, 3, 352, 352], dtype=torch.float32),
torch.rand([4, 352, 352, 2], dtype=torch.float32) * 2 - 1,
),
check_lowp=False,
# Mismatched elements: 154697 / 1486848 (10.4%)
# Greatest absolute difference: 0.0001976490020751953 at index (0, 0, 101, 243) (up to 1e-05 allowed)
# Greatest relative difference: 7.332530120481928 at index (1, 1, 258, 301) (up to 1.3e-06 allowed)
atol=0.0002,
rtol=1.3e-06,
)
def test_upsample_bicubic2d(self):
def fn(a):
return (
aten.upsample_bicubic2d(a, (128, 128), True),
aten.upsample_bicubic2d(a, (128, 256), False),
)
# Mismatched elements: 10 / 196608 (0.0%)
# Greatest absolute difference: 1.3869255781173706e-05 at index (2, 1, 88, 65) (up to 1e-05 allowed)
# Greatest relative difference: 0.0033082996811011046 at index (3, 1, 88, 91) (up to 1.3e-06 allowed)
self.common(
fn,
(torch.randn([4, 3, 64, 32], dtype=torch.float32),),
atol=2e-5,
rtol=1e-3,
)
def test_sort(self):
def fn(a):
return torch.sort(a)
self.common(
fn, (torch.randint(0, 999, size=[1, 1, 8, 8], dtype=torch.float32),)
)
def test_topk(self):
def fn(a):
return torch.topk(a, 2, -1)
self.common(
fn, (torch.randint(0, 999, size=[1, 1, 8, 8], dtype=torch.float32),)
)
def test_long_tensor(self):
def fn(a):
return (
torch.LongTensor([294]).to(a.device) - a,
torch.as_tensor([295]).to(a.device) + a,
)
self.common(fn, (torch.randint(0, 999, size=[8, 8]),))
def test_constant_pad_1d(self):
def fn(a):
return (
aten.constant_pad_nd(a, [0, 1], 6.0),
aten.constant_pad_nd(a, [2, 3], 99.0),
)
self.common(fn, (torch.randint(0, 999, size=[2, 16, 31], dtype=torch.float32),))
def test_constant_pad_fill_dtype(self):
def fn(a, b):
return (
aten.constant_pad_nd(a, (1, 1), 1.0) & b,
aten.constant_pad_nd(a, (1, 1), 0.0) & b,
)
self.common(
fn,
(torch.randint(2, (4,), dtype=torch.bool), torch.ones(6, dtype=torch.bool)),
)
def test_constant_pad_2d(self):
def fn(a):
return (
aten.constant_pad_nd(a, [1, 1, 1, 1], 6.0),
aten.constant_pad_nd(a, [1, 2, 3, 4], 99.0),
)
self.common(
fn, (torch.randint(0, 999, size=[1, 1, 8, 8], dtype=torch.float32),)
)
def test_constant_pad_3d(self):
def fn(a):
return (
aten.constant_pad_nd(a, [1, 2, 3, 4, 5, 6], 6.0),
aten.constant_pad_nd(a, [0, 0, 3, 4, 0, 0], 6.0),
)
self.common(
fn, (torch.randint(0, 999, size=[2, 4, 4, 4], dtype=torch.float32),)
)
def test_constant_pad_float64(self):
# Repro for https://github.com/pytorch/pytorch/issues/93351
def fn(input):
v1 = torch.nn.functional.pad(input, pad=(1, 0))
return torch.gt(v1, input)
x = torch.rand([1, 2, 2, 1], dtype=torch.float64)
self.common(fn, (x,))
def test_constant_pad_nd_inplace(self):
def fn(a):
return aten.constant_pad_nd(a, [0, 0])
x = torch.randn([2], device=self.device)
fn_compiled = torch.compile(fn)
y = fn_compiled(x)
self.assertTrue(y is not x)
def test_l1_loss(self):
def fn(a, b):
return torch.nn.functional.l1_loss(a, b), torch.nn.functional.mse_loss(a, b)
self.common(
fn,
(
torch.randn([2, 3, 16, 16]),
torch.randn([2, 3, 16, 16]),
),
check_lowp=False,
)
def test_triu(self):
def fn(a):
return aten.triu(a, 1), aten.triu(a, 0), aten.triu(a, 2)
self.common(fn, (torch.randn([2, 10, 10]),))
def test_no_op_reduction(self):
def fn(a):
return a.sum(-1), torch.amax(a + 1, 1, keepdim=True)
self.common(fn, (torch.randn([8, 1, 1]),))
def test_inplace_add(self):
@torch._dynamo.optimize("inductor")
def fn(x, y):
return x.add_(y)
inputs = (
rand_strided((4, 4), (4, 1), device=self.device),
rand_strided((4, 4), (4, 1), device=self.device),
)
inp_clone = inputs[0].clone()
out = fn(*inputs)
self.assertTrue(same(out, inp_clone + inputs[1]))
self.assertTrue(out is inputs[0])
# The following 2 tests are meant to check the logic that drops
# xmask from triton load/store if xnumel = 1
@requires_cuda()
def test_single_elem(self):
def fn(a):
b = a + 1
return (b,)
self.common(fn, (torch.randn(1),))
@requires_cuda()
def test_single_elem_indirect(self):
def fn(a, b):
c = a[b] + 1
return (c,)
a = torch.randn(1)
b = (torch.tensor([0], dtype=torch.int64),)
self.common(fn, (a, b))
# This test is meant to check for issues from the logic
# that drops xmask from trito load/store if XBLOCK divides xnumel
@requires_cuda()
def test_xblock_divides_xnumel(self):
def fn(a):
b = a + 1
return (b,)
# assumption is that XBLOCK is always a divisor of 1024
# so xmask will be dropped iff xnumel is multiple of 1024
self.common(fn, (torch.randn(1024),))
self.common(fn, (torch.randn(1025),))
def test_inplace_mixed_dtype_ops(self):
@torch._dynamo.optimize("inductor")
def fn(x, y):
z = x + y.float()
w = z.add_(y)
return w.mul_(y)
inputs = (
rand_strided((4, 4), (4, 1), device=self.device, dtype=torch.float),
rand_strided((4, 4), (4, 1), device=self.device, dtype=torch.double),
)
out = fn(*inputs)
out_eager = (inputs[0] + inputs[1].float()).add_(inputs[1]).mul_(inputs[1])
self.assertTrue(same(out, out_eager))
@config.patch(
{"triton.unique_kernel_names": True, "triton.descriptive_names": False}
)
def test_kernel_names(self):
@torch._dynamo.optimize("inductor")
def fn(x):
return 2 * x
inputs = (rand_strided((8,), (1,), device=self.device),)
self.assertTrue(same(fn(*inputs), 2 * inputs[0]))
@config.patch({"triton.cudagraphs": True if not torch.version.hip else False})
def test_strided_inputs(self):
@torch._dynamo.optimize("inductor")
def fn(x, y):
return x + y
inputs = (
rand_strided((8, 16), (32, 2), device=self.device),
rand_strided((8, 16), (16, 1), device=self.device),
)
self.assertTrue(same(fn(*inputs), inputs[0] + inputs[1]))
@config.patch({"triton.cudagraphs": True if not torch.version.hip else False})
def test_input_mutation1(self):
def fn(a):
b = a + 1
a.copy_(b)
c = a + 2
return a * b / c
arg1 = torch.randn(64, device=self.device)
arg2 = arg1.clone()
arg3 = torch.randn(64, device=self.device)
arg4 = arg3.clone()
correct1 = fn(arg1)
correct2 = fn(arg3)
opt_fn = torch._dynamo.optimize_assert(compile_fx)(fn)
actual1 = opt_fn(arg2)
actual2 = opt_fn(arg4)
self.assertTrue(same(actual1, correct1))
self.assertTrue(same(actual2, correct2))
self.assertTrue(same(arg1, arg2))
self.assertTrue(same(arg3, arg4))
def test_input_mutation2(self):
def fn(a):
b = a + 1
a.view(64).copy_(torch.tensor([66.0], device=a.device))
c = a + 2
return b, c
# NOTE: this test fails when none of the inputs require grad.
# That seems like an inductor bug.
arg1 = torch.randn([1, 64], device=self.device).requires_grad_(True).add(1)
arg2 = arg1.clone()
correct1 = fn(arg1)
opt_fn = torch._dynamo.optimize_assert(compile_fx)(fn)
actual1 = opt_fn(arg2)
self.assertTrue(same(actual1, correct1))
self.assertTrue(same(arg1, arg2))
def test_input_mutation3(self):
def fn(a):
a += 1
a *= 2
aten.sigmoid_(a)
a = a.view(64)
a += 3
a *= 4
aten.relu_(a)
return a
arg1 = torch.randn([1, 64], device=self.device)
arg2 = arg1.clone()
correct1 = fn(arg1)
opt_fn = torch._dynamo.optimize_assert(compile_fx)(fn)
actual1 = opt_fn(arg2)
self.assertTrue(same(actual1, correct1))
self.assertTrue(same(arg1, arg2))
def test_input_mutation4(self):
def fn(a):
torch.relu_(a)
return a
arg1 = torch.randn([1, 64], device=self.device)
arg2 = arg1.clone()
correct1 = fn(arg1)
opt_fn = torch._dynamo.optimize_assert(compile_fx)(fn)
actual1 = opt_fn(arg2)
self.assertTrue(same(actual1, correct1))
self.assertTrue(same(arg1, arg2))
def test_slice_mutation1(self):
def fn(a):
x = torch.zeros_like(a)
b = x + 1
x[:, 3] = 3.0
c = torch.clone(x)
x[4, :] = 4.0
d = x + 1
return x, b, c, d
self.common(fn, (torch.randn([8, 8]),))
def test_slice_mutation2(self):
def fn(a):
a[:, 20:40] = a[:, 20:40] + 1
a[:, 2:11] = a[:, 1:10] + 2
arg1 = torch.randn([1, 64], device=self.device)
arg2 = arg1.clone()
fn(arg1)
opt_fn = torch._dynamo.optimize_assert(compile_fx)(fn)
opt_fn(arg2)
# TODO, fix: See https://github.com/pytorch/pytorch/issues/94693
if self.device != "cpu":
self.assertTrue(same(arg1, arg2))
def test_indirect_load_broadcast(self):
def fn(in_ptr0, in_ptr1, in_ptr2):
return torch.gather(in_ptr1, 0, in_ptr2) + in_ptr0
arg190 = rand_strided((32, 21), (1, 32), device=self.device, dtype=torch.int64)
arg190.fill_(0)
arg111 = rand_strided(
(9521, 512), (512, 1), device=self.device, dtype=torch.float32
)
self.common(
fn,
(
torch.randn(32, 1),
arg111,
arg190,
),
)
@unittest.skipIf(not has_torchvision_roi_align(), "requires torchvision")
def test_roi_align(self):
def fn(a, b):
return torch.ops.torchvision.roi_align(a, b, 0.25, 7, 7, 2, False)
self.common(fn, (torch.zeros([4, 256, 296, 304]), torch.zeros([2292, 5])))
def test_nll_loss_forward(self):
def fn(a, b):
return aten.nll_loss_forward(a, b, None, 1, -100)
labels = (
torch.zeros([5], dtype=torch.int64),
torch.tensor([-100, -100, 3, -100, -100], dtype=torch.int64),
)
inps = (torch.randn(5, 5), torch.randn(5, 5))
for a, b in zip(inps, labels):
self.common(
fn,
(a, b),
)
def test_nll_loss_backward(self):
def fn(a, b, c):
return aten.nll_loss_backward(
a, b, c, None, 1, -100, torch.tensor(1.0, device=self.device)
)
labels = (
torch.zeros([5], dtype=torch.int64),
torch.tensor([-100, -100, 3, -100, -100], dtype=torch.int64),
)
inps = (torch.randn(5, 5), torch.randn(5, 5))
grad_outs = (torch.randn(()), torch.randn(()))
for a, b, c in zip(grad_outs, inps, labels):
self.common(
fn,
(a, b, c),
)
def test_isinf(self):
def fn(x):
return x.isinf(), x.isnan()
self.common(
fn, [torch.tensor([1, float("inf"), 2, float("-inf"), float("nan")])]
)
self.common(
fn,
[
torch.tensor(
[1, float("inf"), 2, float("-inf"), float("nan")],
dtype=torch.float64,
)
],
)
def test_isinf2(self):
def fn(x):
y = torch.tensor(
[1, float("inf"), 2, float("-inf"), float("nan")], device=self.device
)
return x == y
self.common(
fn, (torch.tensor([1, float("inf"), 2, float("-inf"), float("nan")]),)
)
def test_any(self):
def fn(x):
return (
x.any(-1),
x.isinf().any(),
torch.all(x.isinf(), dim=0),
torch.all(torch.logical_not(x.isinf())),
)
self.common(fn, [-torch.rand(64)])
tmp = torch.randn(16, 8)
tmp[1, 1] = float("inf")
self.common(fn, [tmp])
def test_inplace_activations(self):
def fn(x):
a = aten.hardswish_(x + 1)
b = aten.hardtanh_(x + 1)
c = aten.leaky_relu_(x + 1)
d = aten.silu_(x + 1)
e = aten.log1p(x + 1)
f = aten.masked_fill_(x + 1, torch.zeros_like(x, dtype=torch.bool), 99.0)
h = aten.masked_fill_(x + 1, torch.ones_like(x, dtype=torch.bool), 99.0)
return (a, b, c, d, e, f, h)
self.common(fn, [torch.randn(64) * 10])
def test_baddbmm(self):
def fn(a, b, c, beta):
return aten.baddbmm(a, b, c, beta=beta)
b = torch.randn(6, 128, 64)
c = torch.randn(6, 64, 100)
options = itertools.product(
[torch.randn(6, 1, 100), torch.randn(6, 1, 100).fill_(torch.nan)],
[0.0, 1.0],
)
for a, beta in options:
self.common(
fn,
[a, b, c, beta],
# Mismatched elements: 1212 / 76800 (1.6%)
# Greatest absolute difference: 0.001953125 at index (0, 0, 93) (up to 1e-05 allowed)
# Greatest relative difference: 1.0 at index (3, 19, 4) (up to 0.001 allowed)
atol=0.002,
rtol=0.001,
)
@config.patch({"triton.max_tiles": 2})
def test_fuse_tiled(self):
def fn(a, b, c):
return a + b, c + 1
self.common(
fn, [torch.randn(128, 1), torch.randn(1, 128), torch.randn(128, 128)]
)
def test_expand_as(self):
def fn(a, b):
return aten.expand_as(a, b), aten.expand_as(a + 1, b + 1) + 1
self.common(
fn,
[
torch.randn(6, 1, 100),
torch.randn(6, 128, 100),
],
)
def test_index_put1(self):
def fn(a, b, c):
return (
torch.index_put(a, [b], c),
torch.index_put_(a + 1, [b + 1], c + 1) + 1,
)
self.common(
fn,
[
torch.randn([800, 256, 7, 7]),
torch.randperm(601),
torch.randn([601, 256, 7, 7]),
],
)
self.common(
fn, [torch.randn(1024, 4, 2), torch.arange(4), torch.randn(4, 1, 1)]
)
def test_index_put2(self):
def fn(a, b, c):
return torch.index_put(a, [b], c, True)
self.common(
fn,
[
torch.randn([100, 256, 7, 7]),
torch.randint(0, 100, size=[600], dtype=torch.int64),
torch.randn([600, 256, 7, 7]),
],
# workaround for https://github.com/openai/triton/issues/558
check_lowp=False,
)
def test_index_put3(self):
def fn(a, b, c):
torch.ops.aten.index_put_(a, (None, b, None), c)
a1 = a + 1
torch.ops.aten.index_put_(a1, (None, b + 1, None), c + 1)
return (a, a1)
self.common(
fn,
[
torch.randn([1024, 4, 2]),
torch.arange(3),
torch.randn([1024, 1, 2]),
],
)
def test_index_put4(self):
# a, b[0] are not broadcastable
# https://github.com/pytorch/pytorch/issues/97104
def fn(a, b, c):
return torch.index_put(a, [b], c)
self.common(
fn,
[
torch.rand([8, 2]),
torch.rand([8]) > 0.5,
torch.rand([]),
],
)
def test_index_put_as_masked_fill(self):
def fn(a, b, c, d):
a = a.clone()
torch.ops.aten.index_put_(a, [b], c, d)
return a
self.common(
fn,
(
torch.randn([1024, 4, 2]),
torch.randn([1024, 4, 2]) > 0,
torch.randn([]),
False,
),
)
self.common(
fn,
(
torch.randn([1024, 4, 2]),
torch.randn([1024, 4, 2]) > 0,
torch.randn([]),
True,
),
)
def test_index_put_fallback1(self):
def fn(a, b, c, d):
a = a.clone()
torch.ops.aten.index_put_(a, [b], c, d)
return a
self.common(
fn,
(
torch.randn([3]),
torch.as_tensor([True, True, False]),
torch.randn([2]),
False,
),
)
self.common(
fn,
(
torch.randn([3]),
torch.as_tensor([True, True, False]),
torch.randn([2]),
True,
),
)
def test_index_put_fallback2(self):
def fn(a, b, c, d, e):
a = a.clone()
torch.ops.aten.index_put_(a, [None, b, c], d, e)
return a
self.common(
fn,
(
torch.randn([1, 2, 3]),
torch.as_tensor([0, 1]),
torch.as_tensor([True, True, False]),
torch.randn([]),
False,
),
)
self.common(
fn,
(
torch.randn([1, 2, 3]),
torch.as_tensor([0, 1]),
torch.as_tensor([True, True, False]),
torch.randn([]),
True,
),
)
def test_index_put_deterministic_fallback(self):
with DeterministicGuard(True):
def fn(a, b, c):
return torch.index_put(a, [b], c, True)
self.common(
fn,
[
torch.randn([100, 32]),
torch.randint(0, 100, size=[600], dtype=torch.int64),
torch.randn([600, 32]),
],
check_lowp=False,
)
def test_index_put_index(self):
def fn(ind, x, src):
y = torch.ops.aten.index_put.default(x, [ind], src)
return torch.ops.aten.index.Tensor(y, [ind])
args = [torch.tensor([1], dtype=torch.int64), torch.randn(8, 4), torch.randn(4)]
self.common(fn, args)
@config.patch(fallback_random=True)
def test_bernoulli1(self):
def fn(a):
b = torch.empty_like(a)
return aten.bernoulli_(b), b
self.common(
fn,
[
torch.randn([100]),
],
)
def test_bernoulli2(self):
def fn(a):
return aten.bernoulli(a)
self.common(
fn,
[torch.tensor([1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0])],
)
def test_narrow(self):
def fn(x):
return (
aten.narrow(x, 1, 10, 16),
aten.narrow(x + 2, 0, 10, 16) + 1,
aten.narrow_copy(x, 1, 10, 16),
)
self.common(fn, [torch.randn(64, 64)])
def test_as_strided(self):
def fn(x):
return (
aten.as_strided(x, (8, 8, 64), (8 * 64, 64, 1), 0),
aten.as_strided(x + 1, (8, 8, 64), (8 * 64, 64, 1), 0) + 2,
)
def fn_channels_last(x):
return (
aten.as_strided(
x, (8, 384, 2, 20, 12), (153600, 1, 61440, 384, 7680), 0
),
aten.as_strided(
x + 1, (8, 384, 2, 20, 12), (153600, 1, 61440, 384, 7680), 0
)
+ 2,
)
self.common(fn, [torch.randn(64, 64)])
self.common(
fn_channels_last,
[torch.randn(8, 384, 20, 20).to(memory_format=torch.channels_last)],
)
def test_as_strided_scatter(self):
def fn(a, b):
return aten.as_strided_scatter(
a * 8 + 10,
b * 2 - 4,
size=(a.shape[0], a.shape[1] // 2),
stride=(a.shape[1], 2),
storage_offset=0,
)
self.common(fn, [torch.randn(10, 1024), torch.randn(10, 512)])
def test_select_scatter(self):
def fn(x, a, b):
return (
aten.select_scatter(x, a, 1, 0),
aten.select_scatter(x, b, 0, 1),
)
self.common(
fn,
[
torch.randn(8, 197, 38),
torch.randn(8, 38),
torch.randn(197, 38),
],
)
def test_slice_scatter(self):
def fn(x, a):
return (
aten.slice_scatter(x, a, 2, 10, -10),
aten.slice_scatter(x, a[:, :, :40], 2, 10, -10, 2),
)
self.common(
fn,
[
torch.randn(4, 8, 100),
torch.randn(4, 8, 80),
],
)
def test_slice_scatter2(self):
def fn(a, b):
return aten.slice_scatter(a, b, 0, 0, 9223372036854775807)
self.common(
fn,
[
torch.randn([8, 197, 384]),
torch.randn([8, 197, 384]),
],
)
def test_scatter1(self):
def fn(a, dim, index, b):
return aten.scatter(a, dim, index, b)
self.common(
fn,
[
torch.zeros(2, 3),
-1,
torch.tensor([[0]]),
torch.ones(2, 3),
],
)
def test_scatter2(self):
if self.device == "cuda":
raise unittest.SkipTest("unstable on sm86")
def fn(a, dim, index, b):
return aten.scatter.reduce(a, dim, index, b, reduce="add")
self.common(
fn,
[
torch.zeros(64, 512),
0,
torch.zeros((64, 512), dtype=torch.int64),
torch.ones(64, 512),
],
)
def test_scatter3(self):
def fn(a, dim, index, b):
return aten.scatter(a, dim, index, b, reduce="add")
self.common(
fn,
[
torch.randn(5, 29, 13),
2,
torch.tensor([[[3, 5, 7, 9]]]),
0.8, # src can be a scalar
],
# Mismatched elements: 1 / 1885 (0.1%)
# Greatest absolute difference: 0.00018310546875 at index (0, 0, 3) (up to 1e-05 allowed)
# Greatest relative difference: 0.0022371364653243847 at index (0, 0, 3) (up to 0.001 allowed)
atol=2e-4,
rtol=1e-3,
)
def test_scatter4(self):
def fn(x, ind, src):
return torch.scatter(x, 0, ind, src)
for deterministic in [False, True]:
with DeterministicGuard(deterministic):
self.common(
fn,
[
torch.randn(196, 992),
torch.randint(196, (1, 992)),
torch.randn(1, 992),
],
)
def test_scatter5(self):
def fn(a, dim, index, b, reduce):
a = a.clone()
a.scatter_(dim, index, b, reduce=reduce)
a1 = a + 1.0
a1.scatter_(dim, index, b, reduce=reduce)
return (a, a1)
for reduce in ["add", "multiply"]:
self.common(
fn,
[
torch.ones((4, 5)),
0,
torch.tensor([[1], [2], [3]], dtype=torch.int64),
torch.randn(4, 5),
reduce,
],
)
def test_scatter6(self):
def fn(a, dim, index, b):
return aten.scatter(a, dim, index, b)
for deterministic in [False, True]:
with DeterministicGuard(deterministic):
self.common(
fn,
[
torch.randn(5, 8, 13),
2,
torch.tensor([[[3, 5, 7, 9]]]),
0.8, # src can be a scalar
],
)
@unittest.skip("Flaky test, needs debugging")
def test_scatter_add1(self):
def fn(a, dim, index, b):
return aten.scatter_add(a, dim, index, b)
self.common(
fn,
[
torch.randn(2, 3),
0,
torch.tensor([[0]]),
torch.randn(2, 3),
],
)
def test_scatter_add2(self):
def fn(a, dim, index, b):
return aten.scatter_add(a, dim, index, b)
self.common(
fn,
[
torch.randn(2, 3),
0,
torch.tensor([[0, 0, 0], [1, 1, 1]]),
torch.randn(2, 3),
],
)
def test_scatter_add3(self):
def fn(a, dim, index, b):
return aten.scatter_add(a, dim, index, b)
for deterministic in [False, True]:
with DeterministicGuard(deterministic):
self.common(
fn,
[
torch.randn(5, 29, 13),
2,
torch.tensor([[[3, 5, 7, 9]]]),
torch.randn(1, 1, 10),
],
)
def test_scatter_reduce1(self):
def fn(a, dim, index, b):
return aten.scatter_reduce(a, dim, index, b, "sum")
self.common(
fn,
[
torch.randn(5, 29, 13),
2,
torch.tensor([[[3, 5, 7, 9]]]),
torch.randn(1, 1, 10),
],
)
def test_scatter_reduce2(self):
def fn(a, dim, index, b):
return aten.scatter_reduce(a, dim, index, b, "sum", include_self=False)
self.common(
fn,
[
torch.randn(2, 3),
0,
torch.zeros((2, 3), dtype=torch.int64),
torch.randn(2, 3),
],
)
def test_scatter_reduce3(self):
def fn(a, dim, index, b, reduce):
a = a.clone()
a.scatter_reduce_(dim, index, b, reduce=reduce)
a1 = a + 1.0
a1.scatter_reduce_(dim, index, b, reduce=reduce)
return (a, a1)
for reduce in ["sum", "prod"]:
self.common(
fn,
[
torch.ones((4, 5)),
0,
torch.tensor([[1], [2], [3]], dtype=torch.int64),
torch.randn(4, 5),
reduce,
],
)
# issue #1150
def test_dense_mask_index(self):
if self.device == "cpu":
raise unittest.SkipTest(
"https://github.com/pytorch/torchdynamo/issues/1697"
)
def fn(x, y):
y = torch.ops.aten.select.int(y, 0, 2)
z = x * y
return z.sum()
self.common(fn, [torch.randn(102400), torch.randn(3)])
def test_empty1(self):
def fn():
return torch.empty((1, 128, 128))
self.common(fn, [], assert_equal=False)
def test_empty2(self):
def fn():
return aten.empty((1, 128, 128))
self.common(fn, [], assert_equal=False)
def test_new_empty(self):
def fn(a):
return aten.new_empty(a, [1, 128, 128])
self.common(fn, [torch.randn(55)], assert_equal=False)
def test_empty_strided(self):
def fn():
return aten.empty_strided([1, 128, 128], [16384, 128, 1])
self.common(fn, [], assert_equal=False)
def test_new_empty_strided(self):
def fn(a):
return aten.new_empty_strided(a, [1, 128, 128], [16384, 128, 1])
self.common(fn, [torch.randn(55)], assert_equal=False)
def test_dropout_trivial_0(self):
def fn1(a):
return torch.nn.functional.dropout(a, 0.0, True) + a
self.common(fn1, [torch.randn(55)])
def test_dropout_trivial_1(self):
def fn2(a):
return torch.nn.functional.dropout(a, 1.0, True) + a
self.common(fn2, [torch.randn(55)])
@config.patch({"triton.cudagraphs": True})
def test_dropout(self):
random.seed(1234)
torch.manual_seed(1234)
@torch._dynamo.optimize("inductor")
def fn1(a):
return torch.nn.functional.dropout(a)
x = torch.ones(1000, device=self.device, dtype=torch.float32)
result1 = fn1(x)
self.assertTrue(400 < result1.nonzero().shape[0] < 600)
self.assertTrue(0.9 < result1.mean().item() < 1.1)
random.seed(1234)
torch.manual_seed(1234)
@torch._dynamo.optimize("inductor")
def fn2(a):
return torch.nn.functional.dropout(a, 0.5, True)
result2 = fn2(x)
self.assertTrue(400 < result2.nonzero().shape[0] < 600)
self.assertTrue(0.9 < result2.mean().item() < 1.1)
def test_dropout_deterministic(self):
@torch._dynamo.optimize("inductor")
def fn(a):
return torch.nn.functional.dropout(a, 0.55, True)
for cg in [False, True] if not torch.version.hip else [False]:
with patch.object(config.triton, "cudagraphs", cg):
torch._dynamo.reset()
x = torch.ones(1024, device=self.device, dtype=torch.float32)
torch.manual_seed(1234)
a0 = fn(x).clone()
a1 = fn(x).clone()
a2 = fn(x).clone()
torch.manual_seed(1234)
b0 = fn(x).clone()
b1 = fn(x).clone()
b2 = fn(x).clone()
# same seed, same values
self.assertTrue(torch.allclose(a0, b0))
self.assertTrue(torch.allclose(a1, b1))
self.assertTrue(torch.allclose(a2, b2))
# different calls, different values
self.assertFalse(torch.allclose(a0, a1))
self.assertFalse(torch.allclose(a1, a2))
def test_rand_like_deterministic(self):
@torch._dynamo.optimize("inductor")
def fn(a):
return torch.rand_like(a), torch.rand_like(a)
x = torch.ones(1024, device=self.device, dtype=torch.float32)
torch.manual_seed(1234)
a0 = fn(x)[0].clone()
a1 = fn(x)[0].clone()
a2 = fn(x)[0].clone()
torch.manual_seed(1234)
b0 = fn(x)[0].clone()
b1 = fn(x)[0].clone()
b2 = fn(x)[0].clone()
# same seed, same values
self.assertTrue(torch.allclose(a0, b0))
self.assertTrue(torch.allclose(a1, b1))
self.assertTrue(torch.allclose(a2, b2))
# different calls, different values
self.assertFalse(torch.allclose(a0, a1))
self.assertFalse(torch.allclose(a1, a2))
c, d = fn(x)
self.assertFalse(torch.allclose(c, d))
self.assertTrue((c >= 0).all())
self.assertTrue((c < 1).all())
self.assertTrue((d >= 0).all())
self.assertTrue((d < 1).all())
@patch.object(torch._functorch.config, "functionalize_rng_ops", True)
def test_philox_rand(self):
if self.device == "cpu":
raise unittest.SkipTest(
"functionalization of rng ops supported only on CUDA"
)
@torch._dynamo.optimize("inductor")
def fn(x):
a = torch.rand_like(x) * x
a = torch.rand_like(x) * a
return a
def check(x):
torch.manual_seed(123)
a = fn(x)
torch.manual_seed(1234)
b = fn(x)
torch.manual_seed(123)
c = fn(x)
# same seed, same values
self.assertTrue(torch.allclose(a, c))
# different calls, different values
self.assertFalse(torch.allclose(a, b))
check(torch.ones(1024, device=self.device, dtype=torch.float32))
self.assertEqual(torch.cuda._get_rng_state_offset(), 2048)
# Check non-multiple of 4 numel
check(torch.ones(3, device=self.device, dtype=torch.float32))
self.assertEqual(torch.cuda._get_rng_state_offset(), 8)
def test_randn_like_empty(self):
class Model(torch.nn.Module):
def __init__(
self,
):
super().__init__()
def forward(self, v1: torch.Tensor):
vx = v1.min(dim=1).values
v2 = torch.randn_like(vx)
return v2
model = Model()
x = torch.rand(10, 3, 0)
self.common(model, (x,))
def test_randint(self):
@torch.compile(fullgraph=True)
def fn(x):
return (
torch.randint(10, [1024], device=x.device),
torch.randint(-4, 7, [1024], dtype=torch.int32, device=x.device),
torch.randint_like(x, 2**50),
)
torch.manual_seed(12345)
a0, b0, c0 = fn(torch.zeros([40, 40], device=self.device))
self.assertEqual(a0.shape, [1024])
self.assertEqual(b0.shape, [1024])
self.assertEqual(c0.shape, [40, 40])
torch.manual_seed(12345)
a1, b1, c1 = fn(torch.zeros([40, 40], device=self.device))
self.assertEqual(a0, a1)
self.assertEqual(b0, b1)
self.assertEqual(c0, c1)
self.assertEqual(a0.min(), 0)
self.assertEqual(a0.max(), 9)
self.assertEqual(b0.min(), -4)
self.assertEqual(b0.max(), 6)
self.assertGreaterEqual(c0.min(), 0)
self.assertGreater(c0.max(), 2**40)
self.assertLess(c0.max(), 2**50)
@config.patch(fallback_random=True)
def test_like_rands(self):
def fn(x):
return torch.rand_like(x), torch.randn_like(x)
self.common(fn, [torch.zeros([20, 20])])
def test_like_rands2(self):
# rand_like with kwargs `device` of str type
d = self.device
assert isinstance(d, str)
@torch.compile
def fn(x):
return torch.rand_like(x, device=d)
x = torch.ones(10, device=self.device, dtype=torch.float32)
a0 = fn(x).clone()
a1 = fn(x).clone()
self.assertFalse(torch.allclose(a0, a1))
@requires_cuda()
def test_like_rands3(self):
# rand_like with `device` which is different from `x.device`
def test_like_rands_on_different_device(device1, device2):
@torch.compile
def fn(x, device):
return torch.rand_like(x, device=device)
x = torch.ones(10, device=device1, dtype=torch.float32)
return fn(x, device2).clone()
a0 = test_like_rands_on_different_device("cpu", "cuda")
a1 = test_like_rands_on_different_device("cuda", "cpu")
self.assertTrue(a0.device.type == "cuda")
self.assertTrue(a1.device.type == "cpu")
def test_max_pool2d_with_indices_backward(self):
def fn(a, b, c):
return aten.max_pool2d_with_indices_backward(
a, b, [2, 2], [2, 2], [0, 0], [1, 1], False, c
)
x = torch.randn([2, 4, 18, 14])
result, indices = aten.max_pool2d_with_indices(
x,
[2, 2],
[2, 2],
[0, 0],
[1, 1],
False,
)
self.common(
fn,
[
torch.randn_like(result),
x,
indices,
],
)
def test_max_pool2d_with_indices_backward2(self):
def fn(a, b, c):
return aten.max_pool2d_with_indices_backward(
a, b, [3, 3], [2, 2], [1, 1], [1, 1], True, c
)
x = torch.randn([2, 4, 40, 56])
result, indices = aten.max_pool2d_with_indices(
x,
[3, 3],
[2, 2],
[1, 1],
[1, 1],
True,
)
self.common(
fn,
[
torch.randn_like(result),
x,
indices,
],
)
# From https://github.com/pytorch/torchdynamo/issues/1200
def test_max_pool2d_with_indices_backward3(self):
def fn(a, b, c):
return aten.max_pool2d_with_indices_backward(
a, b, [1, 1], [2, 2], [0, 0], [1, 1], False, c
)
x = torch.randn([32, 256, 37, 38])
result, indices = aten.max_pool2d_with_indices(
x,
[1, 1],
[2, 2],
0,
1,
False,
)
self.common(
fn,
[
torch.randn_like(result),
x,
indices,
],
)
# From https://github.com/pytorch/torchdynamo/issues/1352
def test_max_pool2d_with_indices_backward4(self):
def fn(a, b, c):
return aten.max_pool2d_with_indices_backward(
a, b, [5, 5], [1, 1], [2, 2], [1, 1], False, c
)
torch._inductor.metrics.generated_kernel_count = 0
x = torch.randn([2, 64, 3, 4])
result, indices = aten.max_pool2d_with_indices(
x,
[5, 5],
[1, 1],
2,
1,
False,
)
self.common(
fn,
[
torch.randn_like(result),
x,
indices,
],
)
self.assertEqual(torch._inductor.metrics.generated_kernel_count, 1)
def test_max_pool2d_with_indices_backward5(self):
# Window size is too big. Should fallback
def fn(a, b, c):
return aten.max_pool2d_with_indices_backward(
a, b, [13, 13], [1, 1], [2, 2], [1, 1], False, c
)
torch._inductor.metrics.generated_kernel_count = 0
x = torch.randn([2, 64, 20, 20])
result, indices = aten.max_pool2d_with_indices(
x,
[13, 13],
[1, 1],
2,
1,
False,
)
self.common(
fn,
[
torch.randn_like(result),
x,
indices,
],
)
self.assertEqual(torch._inductor.metrics.generated_kernel_count, 0)
# From https://github.com/pytorch/pytorch/issues/93384
def test_max_pool2d_with_indices_backward6(self):
# dilation is not 1. Should fallback
def fn(a, b, c):
return aten.max_pool2d_with_indices_backward(
a, b, [3, 2], [2, 1], [1, 1], [1, 2], False, c
)
torch._inductor.metrics.generated_kernel_count = 0
x = torch.randn([2, 2, 3, 6])
result, indices = aten.max_pool2d_with_indices(
x,
[3, 2],
[2, 1],
[1, 1],
[1, 2],
False,
)
self.common(
fn,
[
torch.randn_like(result),
x,
indices,
],
)
self.assertEqual(torch._inductor.metrics.generated_kernel_count, 0)
def test_issue102546(self):
def fn(x):
return x.mean(0)
self.common(fn, [torch.rand(())])
def test_avg_pool2d_backward(self):
def fn(a, b):
return aten.avg_pool2d_backward(
a,
b,
[2, 2],
[2, 2],
[0, 0],
True,
False,
None,
)
self.common(
fn,
[
torch.randn([2, 4, 7, 7]),
torch.randn([2, 4, 14, 14]),
],
)
@skipIfRocm
def test_avg_pool2d_backward2(self):
def fn(a, b):
return aten.avg_pool2d_backward(
a,
b,
[3, 3],
[1, 1],
[1, 1],
True,
False,
None,
)
self.common(
fn,
[
torch.randn([1, 1, 20, 15]),
torch.randn([1, 1, 20, 15]),
],
)
def test_avg_pool2d_backward3(self):
def fn(a, b):
return aten.avg_pool2d_backward(
a,
b,
[1, 1],
[2, 2],
[0, 0],
False,
False,
None,
)
torch._inductor.metrics.generated_kernel_count = 0
self.common(
fn,
[
torch.randn([1, 2016, 11, 11]),
torch.randn([1, 2016, 21, 21]),
],
)
self.assertEqual(torch._inductor.metrics.generated_kernel_count, 1)
def test_avg_pool2d_backward4(self):
def fn(a, b):
return aten.avg_pool2d_backward(
a,
b,
[13, 13],
[1, 1],
[0, 0],
True,
False,
None,
)
torch._inductor.metrics.generated_kernel_count = 0
self.common(
fn,
[
torch.randn([1, 16, 12, 12]),
torch.randn([1, 16, 24, 24]),
],
check_lowp=False,
)
self.assertEqual(torch._inductor.metrics.generated_kernel_count, 0)
@config.patch(search_autotune_cache=False)
def test_mm_views(self):
def fn(a, b):
return torch.mm(a.view(32, 32), b.view(32, 32))
self.common(
fn,
(
torch.randn([32, 32]).transpose(0, 1),
torch.randn([1, 32, 32]).transpose(0, 1),
),
check_lowp=False,
)
expected_kernel = 0
# codegen mm kernel from template
self.assertEqual(
torch._inductor.metrics.generated_kernel_count, expected_kernel
)
@torch._dynamo.config.patch(dynamic_shapes=True)
@torch._dynamo.config.patch(assume_static_by_default=False)
def test_dtype_sympy_expr(self):
torch._inductor.metrics.disable_cpp_wrapper = 0
@torch._dynamo.optimize_assert("inductor")
def fn(a):
y = a[..., :-1, :].contiguous()
return y
result = fn(torch.randn([1, 2, 16, 4]).requires_grad_())
result.sum().backward()
expected_disable_cpp_wrapper = 0
self.assertEqual(
torch._inductor.metrics.disable_cpp_wrapper, expected_disable_cpp_wrapper
)
def test_dropout2(self):
n = 100000
weight = torch.ones(
n, device=self.device, dtype=torch.float32, requires_grad=True
)
ones = torch.ones(n, device=self.device, dtype=torch.float32)
@torch._dynamo.optimize_assert("inductor")
def run(x, train=True):
return F.dropout(x * weight, 0.33, train)
def check(r, g):
rmean = r.mean().item()
gmean = g.mean().item()
rcount = len(r.nonzero())
gcount = len(g.nonzero())
# dropped elements should match
self.assertTrue(same(r.nonzero(), g.nonzero()))
self.assertEqual(rcount, gcount)
# dropped should be close to 0.33
self.assertGreater(rcount, 0.64 * n)
self.assertGreater(0.68 * n, rcount)
self.assertAlmostEqual(rmean, gmean)
self.assertAlmostEqual(rmean, 1.0, places=2)
r1 = run(ones, train=False)
r1.sum().backward()
g1 = weight.grad.clone()
# eval mode should be all ones
self.assertTrue(same(r1, torch.ones_like(r1)))
self.assertTrue(same(g1, torch.ones_like(g1)))
torch.manual_seed(1234)
weight.grad.zero_()
r2, (fw_code, bw_code) = run_fw_bw_and_get_code(lambda: run(ones))
if self.device == "cuda":
self.assertEqual(fw_code.count("tl.rand"), 1)
self.assertEqual(bw_code.count("tl.rand"), 0)
g2 = weight.grad.clone()
check(r2, g2)
torch.manual_seed(1234)
weight.grad.zero_()
r3 = run(ones)
r3.sum().backward()
g3 = weight.grad.clone()
check(r3, g3)
# second run is same result as first
self.assertTrue(same(r2, r3))
self.assertTrue(same(g2, g3))
@config.patch(search_autotune_cache=False)
def test_dropout3(self):
m = torch.nn.Sequential(
torch.nn.Linear(32, 32, bias=False),
torch.nn.Dropout(),
torch.nn.Linear(32, 32, bias=False),
torch.nn.Dropout(),
).to(self.device)
@torch._dynamo.optimize_assert("inductor")
def run(x):
return m(x)
torch._inductor.metrics.generated_kernel_count = 0
result, (fw_code, bw_code) = run_fw_bw_and_get_code(
lambda: run(torch.randn([8, 32], device=self.device))
)
if self.device == "cuda":
self.assertEqual(fw_code.count("tl.rand"), 1)
self.assertEqual(bw_code.count("tl.rand"), 0)
expected_kernel = 4
else:
expected_kernel = 6
self.assertEqual(
torch._inductor.metrics.generated_kernel_count, expected_kernel
)
def test_randint_kernel_count(self):
@torch._dynamo.optimize_assert("inductor")
def fn1():
random_tensor1 = torch.randint(10, [32], device=self.device)
random_tensor2 = torch.randint(10, [32], device=self.device)
random_tensor3 = torch.randint(10, [32], device=self.device)
return random_tensor1, random_tensor2, random_tensor3
_, source_codes = run_and_get_code(fn1)
if self.device == "cuda":
self.assertEqual(len(source_codes), 1)
self.assertEqual(source_codes[0].count("async_compile.triton"), 1)
def test_roll(self):
def fn(a):
return (
aten.roll(a, [-3, 10], [1, 2]),
aten.roll(a, [5]),
)
self.common(
fn,
[
torch.randn([2, 56, 56, 16]),
],
)
def test_argmax_min_int32(self):
# https://github.com/pytorch/pytorch/issues/94055
def fn(a, b):
c = a.argmax(3)
return torch.min(b, c)
a = torch.rand(3, 4, 2, 1).int()
b = torch.rand(2, 2, 1, 4, 1).int()
self.common(fn, (a, b))
def test_argmax_argmin1(self):
def fn(x):
return (aten.argmax(x), aten.argmin(x))
self.common(
fn,
[
torch.randn([8, 256, 256]),
],
)
def test_argmax_argmin2(self):
def fn(x):
return (
aten.argmax(x, 0),
aten.argmin(x, 0),
aten.argmax(x, 1),
aten.argmin(x, 1),
)
self.common(fn, (torch.randn([144, 144]),))
def test_argmax_argmin_with_duplicates(self):
def fn(x):
return (
aten.argmax(x, 0),
aten.argmin(x, 0),
aten.argmax(x, 1),
aten.argmin(x, 1),
)
# Unrolled reduction
t1 = torch.randint(2, size=(6, 6))
self.common(fn, (t1,))
# Persistent reduction
t1 = torch.randint(8, size=(32, 32))
self.common(fn, (t1,))
# Non-persistent reduction
t1 = torch.randint(8, size=(1028, 1028))
self.common(fn, (t1,))
def test_argmax_argmin_with_nan(self):
def fn(x):
return (
aten.argmax(x, 0),
aten.argmin(x, 0),
aten.argmax(x, 1),
aten.argmin(x, 1),
)
if self.device == "cpu":
raise unittest.SkipTest("broken on CPU")
# Unrolled reduction
t1 = torch.randn((6, 6))
t1[:, 1] = float("nan")
t1[:, 3] = float("nan")
self.common(fn, (t1,))
# Persistent reduction
t1 = torch.randn((32, 32))
t1[:, 4] = float("nan")
t1[:, 8] = float("nan")
self.common(fn, (t1,))
# Non-persistent reduction
t1 = torch.randn((1028, 1028))
t1[:, 40] = float("nan")
t1[:, 100] = float("nan")
self.common(fn, (t1,))
def test_conv_backward(self):
def fn(rank4_inps, rank3_inps, rank5_inps):
out1 = aten.convolution_backward(
*rank4_inps,
[C],
[1, 1],
[0, 0],
[1, 1],
False,
[0, 0],
1,
[True, True, True],
)
out2 = aten.convolution_backward(
*rank4_inps,
[C],
[1, 1],
[0, 0],
[1, 1],
False,
[0, 0],
1,
[True, False, False],
)
out3 = aten.convolution_backward(
*rank3_inps,
[C],
[1],
[0],
[1],
False,
[0],
1,
[True, True, True],
)
out4 = aten.convolution_backward(
*rank5_inps,
[C],
[1, 1, 1],
[0, 0, 0],
[1, 1, 1],
False,
[0, 0, 0],
1,
[True, True, True],
)
return (out1, out2, out3, out4)
B = 3
C = 4
H = 5
grad_out = torch.randn(B, C, H - 2, H - 2, H - 2)
inp = torch.randn(B, C, H, H, H)
weight = torch.randn(C, C, 3, 3, 3)
def shrink_rank(x, rank):
res = x
while res.dim() > rank:
res = torch.select(res, -1, 0)
return res.contiguous()
rank4_inps = [shrink_rank(x, 4) for x in [grad_out, inp, weight]]
rank3_inps = [shrink_rank(x, 4) for x in [grad_out, inp, weight]]
rank5_inps = [shrink_rank(x, 5) for x in [grad_out, inp, weight]]
with torch.backends.cudnn.flags(enabled=True, allow_tf32=False):
self.common(
fn,
[rank4_inps, rank3_inps, rank5_inps],
)
@unittest.skip(
"""
FIXME: In the case of having equally max/min elements, our implementation returns
the last index instead of the first one
"""
)
def test_argmax_argmin3(self):
def fn(x):
return (
aten.argmax(x, 0),
aten.argmin(x, 0),
aten.argmax(x, -1),
aten.argmin(x, -1),
)
self.common(
fn,
[torch.randint(0, 5, [10, 10])],
)
def test_vdd_clamp(self):
def fn(x):
return torch.clamp_min(x, 3)
self.common(
fn,
[
torch.randn([16], requires_grad=True) * 10,
],
)
def test_tmp_not_defined_issue1(self):
def forward(
primals_3,
primals_4,
add_tensor,
convert_element_type_default,
div_default,
reciprocal_default,
):
var_default = torch.ops.aten.var(
convert_element_type_default, [2], correction=0
)
sub_tensor = torch.ops.aten.sub.Tensor(add_tensor, div_default)
mul_tensor_1 = torch.ops.aten.mul.Tensor(sub_tensor, reciprocal_default)
mul_tensor_2 = torch.ops.aten.mul.Tensor(mul_tensor_1, primals_3)
add_tensor_2 = torch.ops.aten.add.Tensor(mul_tensor_2, primals_4)
convert_element_type_default_1 = add_tensor_2.to(dtype=torch.float32)
convert_element_type_default_2 = convert_element_type_default_1.to(
dtype=torch.float32
)
var_default_1 = torch.ops.aten.var(
convert_element_type_default_2, [2], correction=0
)
broadcast_in_dim_default_2 = var_default_1.reshape(1, 512, 1)
sum_default_1 = convert_element_type_default_2.sum(2)
add_tensor_3 = torch.ops.aten.add.Tensor(broadcast_in_dim_default_2, 1e-05)
return (var_default, sum_default_1, add_tensor_3)
inps = [
(torch.Size([1024]), torch.float32),
(torch.Size([1024]), torch.float32),
(torch.Size([1, 512, 1024]), torch.float32),
(torch.Size([1, 512, 1024]), torch.float32),
(torch.Size([1, 512, 1]), torch.float32),
(torch.Size([1, 512, 1]), torch.float32),
]
inps = [torch.randn(shape, dtype=dtype) for (shape, dtype) in inps]
self.common(forward, inps, atol=1e-05, rtol=2e-05)
@unittest.skipIf(
TEST_WITH_ASAN
or os.environ.get("BUILD_ENVIRONMENT", "").startswith("parallelnative"),
"TODO: debug this with asan",
)
def test_tmp_not_defined_issue2(self):
def forward(arg38_1, arg81_1, getitem_17, new_zeros_default_4):
div_tensor_7 = torch.ops.aten.div.Tensor(getitem_17, arg81_1)
mul_tensor_24 = torch.ops.aten.mul.Tensor(div_tensor_7, arg38_1)
sum_default_7 = torch.ops.aten.sum.default(mul_tensor_24)
return (new_zeros_default_4, sum_default_7)
# TODO: Remove once https://github.com/pytorch/pytorch/issues/94017 is resolved
dtype = torch.float64 if self.device == "cpu" else torch.float32
args = [
((1, 88, 40, 40), (140800, 1600, 40, 1), dtype),
((), (), dtype),
((1, 88, 40, 40), (140800, 1600, 40, 1), dtype),
((3,), (1,), dtype),
]
args = [
rand_strided(shape, stride, dtype).requires_grad_(True).add(1)
for shape, stride, dtype in args
]
self.common(forward, args)
def test_misaligned_address_issue1(self):
def forward(sub_tensor_1, unsqueeze_default):
gather_default = torch.ops.aten.gather.default(
sub_tensor_1, 1, unsqueeze_default
)
return gather_default
args = [
((1, 1000), (1000, 1), torch.float32),
((1, 1), (1, 1), torch.int64),
]
args = [rand_strided(shape, stride, dtype) for shape, stride, dtype in args]
self.common(forward, args)
def test_invalid_operand_issue1(self):
def forward(arg0_1, arg1_1, arg3_1, squeeze, view_1, slice_1):
slice_scatter = torch.ops.aten.slice_scatter.default(
slice_1, arg3_1, 1, 1, 9223372036854775807
)
slice_scatter_1 = torch.ops.aten.slice_scatter.default(
arg1_1, slice_scatter, 0, 0, 9223372036854775807
)
slice_2 = torch.ops.aten.slice.Tensor(
slice_scatter_1, 0, 0, 9223372036854775807
)
select_scatter = torch.ops.aten.select_scatter.default(
slice_2, squeeze, 1, 0
)
slice_scatter_2 = torch.ops.aten.slice_scatter.default(
slice_scatter_1, select_scatter, 0, 0, 9223372036854775807
)
view = torch.ops.aten.view.default(slice_scatter_2, [-1, 128])
embedding = torch.ops.aten.embedding.default(arg0_1, view, 1)
return [embedding, view_1]
args = [
((50005, 768), (768, 1), torch.float32),
((8, 128), (128, 1), torch.int64),
((8, 127), (127, 1), torch.int64),
((8,), (1,), torch.int64),
((1024,), (1,), torch.int64),
((8, 128), (128, 1), torch.int64),
]
args = [rand_strided(shape, stride, dtype) for shape, stride, dtype in args]
self.common(forward, args)
def test_sizehint_issue1(self):
def forward(x):
return torch.nn.functional.unfold(
x, kernel_size=[4, 4], dilation=1, padding=0, stride=[4, 4]
)
args = [((2, 24, 56, 56), (75264, 3136, 56, 1), torch.float32, False)]
args = [
rand_strided(sh, st, dt).requires_grad_(rg) for (sh, st, dt, rg) in args
]
self.common(forward, args)
def test_zero_dim_reductions(self):
for kd in [True, False]:
inps0 = (torch.zeros(2, 0, device=self.device, dtype=torch.float16), 1, kd)
failed_ops = [aten.argmin, aten.argmax, aten.max, aten.min]
for fo in failed_ops:
with self.assertRaisesRegex(
IndexError, "Expected reduction dim 1 to have non-zero size"
):
mod = make_fx(fo)(*inps0)
_ = compile_fx_inner(mod, inps0)
pass_ops = [
lambda *x: fn(*x) for fn in [aten.sum, aten.prod, aten.any, aten.all]
]
for po in pass_ops:
compiled = torch._dynamo.optimize("inductor")(po)
expected = po(*inps0)
actual = compiled(*inps0)
self.assertTrue(torch.allclose(actual, expected, atol=1e-3, rtol=1e-3))
def test_lerp(self):
# non-contiguous inputs for lerp
def fn0(i0, i1):
x1 = i0.transpose(-2, -3)
return torch.lerp(i1, x1, 70000)
# contiguous inputs for lerp
def fn1(i0, i1):
return torch.lerp(i1, i0, 70000)
def compare(fn, inputs):
compiled = torch._dynamo.optimize("inductor")(fn)
expected = fn(*inputs)
actual = compiled(*inputs)
self.assertEqual(expected, actual)
self.assertEqual(expected.stride(), actual.stride())
compare(fn0, [torch.rand(10, 3, 10), torch.rand(3, 10, 10)])
compare(fn1, [torch.rand(3, 10, 10), torch.rand(3, 10, 10)])
def test_unspec_inputs(self):
if self.device == "cpu":
raise unittest.SkipTest("segfault with CPU backend")
def fn(x, y):
return x + y, x * y, x / y
opt = torch._dynamo.optimize("inductor")(fn)
dtypes = [
torch.float16,
torch.bfloat16,
torch.float32,
torch.float64,
torch.int32,
torch.int64,
]
for d in dtypes:
inputs = (
rand_strided((2, 3), (3, 1), dtype=torch.float32, device="cuda"),
rand_strided((), (), dtype=d, device="cpu"),
)
self.assertTrue(same(opt(*inputs), fn(*inputs)))
inputs = (inputs[1], inputs[0])
self.assertTrue(same(opt(*inputs), fn(*inputs)))
def test_list_clearing(self):
if self.device == "cpu":
contexts = [contextlib.nullcontext]
else:
contexts = [
contextlib.nullcontext,
lambda: config.patch(
{"triton.cudagraphs": True if not torch.version.hip else False}
),
]
for context in contexts:
with context():
inps = [
torch.rand([5, 5]).to(self.device),
torch.rand([5, 5]).to(self.device),
]
inp_refs = [weakref.ref(inp) for inp in inps]
def fn(x, y):
a = x + y
return (a @ a,)
fn_fx = make_fx(fn)(inps[0], inps[1])
fn_compiled = compile_fx_inner(fn_fx, inps)
test_self = self
matmul_seen = False
class TestRefMode(TorchDispatchMode):
def __torch_dispatch__(self, func, types, args=(), kwargs=None):
kwargs = kwargs if kwargs else {}
nonlocal inps
nonlocal inp_refs
nonlocal test_self
nonlocal matmul_seen
# by matmul, inputs should be deallocated
if func is aten.mm.out:
matmul_seen = True
test_self.assertEqual(len(inps), 0)
test_self.assertIsNone(inp_refs[0]())
test_self.assertIsNone(inp_refs[1]())
return func(*args, **kwargs)
with TestRefMode():
fn_compiled(inps)
# do an extra run to make sure we are deallocating on warmup and record
if self.device == "cuda":
inps.extend(
[
torch.rand([5, 5]).to(self.device),
torch.rand([5, 5]).to(self.device),
]
)
inp_refs.extend([weakref.ref(inp) for inp in inps])
matmul_seen = False
with TestRefMode():
fn_compiled(inps)
# for some reason, TorchDispatch doesnt capture the
# cuda mm call (even without cudagraphs)
if self.device == "cpu":
self.assertTrue(matmul_seen)
else:
self.assertEqual(len(inps), 0)
def test_dtype_mismatch_issue(self):
def fn(x):
attn = torch.nn.functional.pad(x, [0, 1])
return attn.softmax(dim=-1)
x = torch.rand(128, 32, 63)
res_ref = fn(x)
res = torch._dynamo.optimize("inductor")(fn)(x)
self.assertEqual(res, res_ref)
def test_kwargs(self):
if self.device == "cuda":
raise unittest.SkipTest("histogramdd only supports cpu")
def fn(x, y):
return torch.histogramdd(
x,
bins=[3, 3],
weight=y,
)
self.common(
fn,
[torch.randn((4, 2)), torch.randn((4))],
)
@requires_cuda()
@skipIfRocm
@torch._inductor.config.patch("shape_padding", True)
def test_shape_padding(self):
if torch._dynamo.config.dynamic_shapes:
raise unittest.SkipTest("dynamic shapes do not support padding")
dtypes = [
torch.float16,
torch.float32,
]
b, m, n, k = 7, 11, 13, 15
def gen(*shape, dtype=torch.float32):
return torch.randn(*shape, device="cuda", dtype=dtype) / k + 1.0
for dtype in dtypes:
x = gen(m, k, dtype=dtype)
y = gen(k, n, dtype=dtype)
z = gen(n, dtype=dtype)
self.common(lambda x, y: torch.mm(x, y), (x, y))
self.common(lambda x, y: torch.matmul(x, y), (x, y))
self.common(lambda x, y, z: torch.addmm(z, x, y), (x, y, z))
for dtype in dtypes:
x = gen(b, m, k, dtype=dtype)
y = gen(b, k, n, dtype=dtype)
z = gen(n, dtype=dtype)
self.common(lambda x, y: torch.bmm(x, y), (x, y))
self.common(lambda x, y: torch.matmul(x, y), (x, y))
self.common(lambda x, y, z: torch.baddbmm(z, x, y), (x, y, z))
@torch._dynamo.config.patch(dynamic_shapes=True)
def test_int_input_dynamic_shapes(self):
@torch.compile(dynamic=True)
def fn(x, i):
y = x * i
return y
# Constant must not get matched as constant
self.common(fn, [torch.randn(3, 1, 1, 1, 1), 9132])
@torch._dynamo.config.patch(dynamic_shapes=True)
def test_sqrt_dynamic_shapes(self):
# TIMM convit_base model: https://github.com/pytorch/pytorch/issues/97877.
# TODO: support cuda path.
if self.device == "cuda":
raise unittest.SkipTest("sqrt dynamic shapes only supports cpu")
class Model(torch.nn.Module):
def __init__(self):
super(Model, self).__init__()
def forward(self, x):
B, N, C = x.shape
return self.get_rel_indices(N)
def get_rel_indices(self, num_patches: int) -> torch.Tensor:
img_size = int(num_patches**0.5)
ind = torch.arange(img_size)
return ind
self.common(
Model(),
[
torch.randn(8, 4, 4),
],
)
@torch._dynamo.config.patch(dynamic_shapes=True)
def test_index_dynamic_shapes(self):
if self.device == "cuda":
raise unittest.SkipTest("index dynamic shapes only supports cpu")
# Repro from vision_maskrcnn
def fn(arg0_1):
unsqueeze = arg0_1.unsqueeze(0)
sym_size = arg0_1.size(1)
ceil = math.ceil(sym_size * 1.8735363483428955)
iota = torch.ops.prims.iota.default(
ceil,
start=0,
step=1,
dtype=torch.int64,
device="cpu",
requires_grad=False,
)
convert_element_type_1 = iota.to(torch.float32)
sym_size_1 = arg0_1.size(2)
floor_1 = math.floor(sym_size_1 * 1.8735363483428955)
ceil_1 = math.ceil(floor_1)
iota_1 = torch.ops.prims.iota.default(
ceil_1,
start=0,
step=1,
dtype=torch.int64,
device="cpu",
requires_grad=False,
)
convert_element_type_3 = iota_1.to(torch.float32)
sub_2 = (convert_element_type_1 + 0.5) * (sym_size / ceil) - 0.5
clamp_min = sub_2.clamp_min(0.0)
sub_3 = (convert_element_type_3 + 0.5) * (sym_size_1 / floor_1) - 0.5
clamp_min_1 = sub_3.clamp_min(0.0)
convert_element_type_4 = clamp_min.to(torch.int64)
sub_4 = sym_size - 1
clamp_max = clamp_min.ceil().clamp_max(sub_4)
convert_element_type_5 = clamp_max.to(torch.int64)
convert_element_type_6 = clamp_min_1.to(torch.int64)
unsqueeze_2 = convert_element_type_4.unsqueeze(1)
index = torch.ops.aten.index.Tensor(
unsqueeze, [None, None, unsqueeze_2, convert_element_type_6]
)
index_1 = torch.ops.aten.index.Tensor(
unsqueeze,
[
None,
None,
convert_element_type_5.unsqueeze(1),
convert_element_type_6,
],
)
sub_6 = clamp_min.unsqueeze(1) - unsqueeze_2
mul_10 = (index * (1.0 - sub_6) + index_1 * (sub_6)) * (
1.0 - (clamp_min_1 - convert_element_type_6)
)
select = torch.ops.aten.select.int(mul_10, 0, 0)
return (select,)
x = torch.randn(15, 20, 3)
self.common(
fn,
[x],
)
@config.patch(profiler_mark_wrapper_call=True)
def test_profiler_mark_wrapper_call(self):
from torch.profiler import profile
@torch._dynamo.optimize("inductor", nopython=True)
def fn(a, b):
return a + b
a = torch.rand((100,))
b = torch.rand((100,))
with profile() as prof:
fn(a, b)
assert any(
"inductor_wrapper_call" in e.name for e in prof.profiler.function_events
)
@unittest.skipIf(IS_X86 and not HAS_AVX2, "Requires AVX2")
def test_pixel_shuffle_channels_last(self):
def fn(x):
x = torch.nn.functional.pixel_shuffle(x, 2)
x = torch.nn.functional.relu(x)
return x
self.common(
fn,
(torch.randn(1, 16, 64, 72).to(memory_format=torch.channels_last),),
)
def test_where_broadcast(self):
# https://github.com/pytorch/pytorch/issues/93374
def fn(x, p1, p0):
o = torch.where(x, p1, p0)
return o
# https://github.com/pytorch/pytorch/issues/94725
class Repro(torch.nn.Module):
def __init__(self):
super().__init__()
self.register_buffer(
"_tensor_constant0", torch.randn([], dtype=torch.float32)
)
def forward(self, arg0_1, arg1_1):
convert_element_type = torch.ops.prims.convert_element_type.default(
arg1_1, torch.bool
)
bitwise_not = torch.ops.aten.bitwise_not.default(convert_element_type)
_tensor_constant0 = self._tensor_constant0
lift_fresh_copy = torch.ops.aten.lift_fresh_copy.default(
_tensor_constant0
)
where = torch.ops.aten.where.self(bitwise_not, lift_fresh_copy, arg0_1)
return (where, bitwise_not)
self.common(
fn,
(torch.tensor([[True]]), torch.rand(13, 7, 3), torch.rand(1, 1)),
)
if not torch._dynamo.config.dynamic_shapes:
args = [
torch.randn(1, 4, 64, 64),
torch.zeros(1, 1, 64, 64, dtype=torch.uint8),
]
args[1][:, :, :32, :32] = 1
eager_args = [x.clone() for x in args]
eager_mod = Repro()
mod = make_fx(eager_mod, tracing_mode="real")(*args)
compiled = compile_fx_inner(mod, args)
inductor_out = compiled(args)
eager_out = eager_mod(*eager_args)
self.assertEqual(inductor_out, eager_out)
def test_where_with_logical_op(self):
def fn_and(x, y):
return torch.where(torch.logical_and(x, y), 1.0, 0.0)
def fn_or(x, y):
return torch.where(torch.logical_or(x, y), 1.0, 0.0)
self.common(
fn_and,
(torch.randn(32), torch.randn(32)),
)
self.common(
fn_or,
(torch.randn(32), torch.randn(32)),
)
def test_inplace_where_pointwise(self):
# https://github.com/pytorch/pytorch/issues/96446
def fn(a, b):
a[0] = 2
return a * b
self.common(fn, (torch.rand(1), torch.rand(2)))
def test_view_on_aliased(self):
# https://github.com/pytorch/pytorch/issues/96728
def fn1(a, b):
a = a.max(0).values
c = torch.cat((a, b))
c = c.round()
b >= a[0] # noqa: B015
return c
some_const = torch.tensor(6324)
def fn2():
a = torch.tensor([[0.6324]])
ret = torch.cat((a, a), dim=0)
some_const >= a[0] # noqa: B015
return ret
self.common(fn1, (torch.tensor([[4.0]]), torch.tensor([5.0])))
self.common(fn2, ())
def test_argmax_to_float(self):
# https://github.com/pytorch/pytorch/issues/97127
def fn():
a = torch.zeros([2, 2])
b = a.argmax(0)
return b.float().mean()
self.common(fn, ())
def test_const_int32_to_float(self):
# https://github.com/pytorch/pytorch/issues/97124
def fn():
a = torch.zeros([1, 2], dtype=torch.int32)
a = a + a
b = a.to(dtype=torch.float32)
return b * 0.8
self.common(fn, ())
def test_getitem(self):
out_features = ["p3", "p4", "p5", "p6", "p7"]
in_feature = "p5"
def fn(a):
return a[out_features.index(in_feature)]
for dynamic_shapes in [True, False]:
with torch._dynamo.config.patch(dynamic_shapes=dynamic_shapes):
torch._dynamo.reset()
x = [
torch.rand([1, 256, 100, 152]),
torch.rand([1, 256, 50, 76]),
torch.rand([1, 256, 25, 38]),
]
opt_fn = torch._dynamo.optimize("inductor")(fn)
same(fn(x), opt_fn(x))
def test_pad_view(self):
def fn(a):
y = torch.nn.functional.pad(a, (0, 0, 0, 1))
y = y.view(*y.size()[:-2], y.size(-1), y.size(-2))
return y
for dynamic_shapes in [True, False]:
with torch._dynamo.config.patch(dynamic_shapes=dynamic_shapes):
torch._dynamo.reset()
x = torch.rand(48, 3, 512, 512)
opt_fn = torch._dynamo.optimize("inductor")(fn)
same(fn(x), opt_fn(x))
def test_data_type_propogation(self):
_graph: torch.fx.Graph = torch.fx.Graph()
ops: torch.fx.Node = _graph.create_node("placeholder", "ops")
get_index: torch.fx.Node = _graph.create_node(
"call_module", "get_index", args=("index0",)
)
c1: torch.fx.Node = _graph.create_node(
"call_method",
"constant",
args=(
ops,
get_index,
torch.bfloat16,
),
)
c2: torch.fx.Node = _graph.create_node(
"call_method",
"constant",
args=(
ops,
get_index,
torch.float,
),
)
add: torch.fx.Node = _graph.create_node(
"call_method",
"add",
args=(
ops,
c1,
c2,
),
)
eq: torch.fx.Node = _graph.create_node(
"call_method",
"eq",
args=(
ops,
add,
add,
),
)
argmin: torch.fx.Node = _graph.create_node(
"call_method",
"reduction",
args=(
ops,
"buf",
torch.int64,
torch.int64,
"argmin",
get_index,
add,
),
)
any: torch.fx.Node = _graph.create_node(
"call_method",
"reduction",
args=(
ops,
"buf",
torch.bool,
torch.bool,
"any",
get_index,
add,
),
)
bitwise_not: torch.fx.Node = _graph.create_node(
"call_method",
"bitwise_not",
args=(
ops,
argmin,
),
)
bitwise_or: torch.fx.Node = _graph.create_node(
"call_method",
"bitwise_or",
args=(
ops,
eq,
any,
),
)
bitwise_left_shift: torch.fx.Node = _graph.create_node(
"call_method",
"bitwise_left_shift",
args=(
ops,
argmin,
bitwise_not,
),
)
DataTypePropagation.propagate_graph(_graph)
def get_data_type(node: torch.fx.Node):
if OptimizationContext.key in node.meta:
return node.meta[OptimizationContext.key].dtype
else:
return None
self.assertEqual(get_data_type(ops), None)
self.assertEqual(get_data_type(c1), torch.bfloat16)
self.assertEqual(get_data_type(c2), torch.float)
self.assertEqual(get_data_type(add), torch.float)
self.assertEqual(get_data_type(eq), torch.bool)
self.assertEqual(get_data_type(argmin), torch.int64)
self.assertEqual(get_data_type(any), torch.bool)
self.assertEqual(get_data_type(bitwise_not), torch.int64)
self.assertEqual(get_data_type(bitwise_or), torch.bool)
self.assertEqual(get_data_type(bitwise_left_shift), torch.int64)
def test_AllenaiLongformerBase_repro(self):
def fn(query, scores, window_overlap):
batch_size, seq_len, num_heads, _ = query.size()
chunks_count = torch.div(seq_len, window_overlap, rounding_mode="trunc") - 1
diagonal_attention_scores = scores.new_zeros(
(
batch_size * num_heads,
chunks_count + 1,
window_overlap,
window_overlap * 2 + 1,
)
)
diagonal_attention_scores[:, :-1, :, window_overlap:] = scores[
:, :, :window_overlap, : window_overlap + 1
]
input_tensor = diagonal_attention_scores.view(
batch_size, num_heads, seq_len, 2 * window_overlap + 1
).transpose(2, 1)
beginning_input = input_tensor[:, :window_overlap, :, : window_overlap + 1]
input_tensor[:, :window_overlap, :, : window_overlap + 1] = torch.full_like(
beginning_input, -float("inf")
)
return input_tensor
for dynamic_shapes in [True, False]:
with torch._dynamo.config.patch(dynamic_shapes=dynamic_shapes):
torch._dynamo.reset()
args = [
((4, 1024, 12, 64), (768, 3072, 64, 1), torch.float32, "cpu"),
((48, 3, 512, 513), (787968, 262656, 513, 1), torch.float32, "cpu"),
]
args = [rand_strided(sh, st, dt, dev) for (sh, st, dt, dev) in args]
opt_fn = torch._dynamo.optimize("inductor")(fn)
same(fn(*args, 256), opt_fn(*args, 256))
def test_cumsum_pattern_matcher_issue(self):
def fn(input_ids) -> torch.Tensor:
input_shape = input_ids.size()
input_ids = input_ids.view(-1, input_shape[-1])
batch_size, seq_length = input_shape
past_key_values_length = 0
mask_seq_length = past_key_values_length + seq_length
attention_mask = torch.ones(batch_size, mask_seq_length)
attention_mask = attention_mask.long()
return torch.cumsum(attention_mask, dim=1)
for dynamic_shapes in [True, False]:
with torch._dynamo.config.patch(dynamic_shapes=dynamic_shapes):
torch._dynamo.reset()
x = torch.randn(2, 2)
opt = torch._dynamo.optimize("inductor")(fn)
res = opt(x)
ref = fn(x)
self.assertEqual(res, ref, atol=0, rtol=0)
def test_slice(self):
def fn(a, b):
return torch.ops.aten.slice.Tensor(a, 0, 0, -b)
for dynamic_shapes in [True, False]:
with torch._dynamo.config.patch(dynamic_shapes=dynamic_shapes):
torch._dynamo.reset()
x = torch.rand(48, 3, 512, 512)
opt_fn = torch._dynamo.optimize("inductor")(fn)
same(fn(x, 2), opt_fn(x, 2))
def test_inplace_resize_as(self):
def fn(x, y):
x.resize_as_(y)
return x
x = torch.randn(2, 3)
y = torch.randn(200, 300)
x_clone = x.clone()
opt_fn = torch._dynamo.optimize("inductor")(fn)
same(fn(x, y), opt_fn(x_clone, y))
def test_erfc(self):
def fn(x):
return torch.erfc(x)
self.common(fn, (torch.randn(8, 8),))
def test_erfinv(self):
def fn(x):
return torch.erfinv(x)
# domain for erfinv is (-1, 1)
x = torch.empty(8, 8).uniform_(-1, 1)
self.common(fn, (x,))
def test_uint(self):
def fn(z):
x = torch.tensor(5, device=z.device, dtype=torch.uint8)
y = torch.neg(x)
return x < y
self.common(fn, (torch.randn(26),))
@skipIfRocm
def test_scaled_dot_product_efficient_attention(self):
if self.device == "cpu":
raise unittest.SkipTest("requires CUDA")
def fn(q, k, v, compute_log_sumexp):
return aten._scaled_dot_product_efficient_attention(
q, k, v, compute_log_sumexp
)
self.common(
fn,
(
torch.randn(4, 4, 36, 36),
torch.randn(4, 4, 36, 36),
torch.randn(4, 4, 36, 36),
False,
),
check_lowp=False,
)
@dataclasses.dataclass
class TestFailure:
suffixes: Tuple[str]
is_skip: bool = False
__test__: bool = False
def copy_tests(my_cls, other_cls, suffix, test_failures=None): # noqa: B902
for name, value in my_cls.__dict__.items():
if name.startswith("test_"):
# You cannot copy functions in Python, so we use closures here to
# create objects with different ids. Otherwise, unittest.skip
# would modify all methods sharing the same object id. Also, by
# using a default argument, we create a copy instead of a
# reference. Otherwise, we would lose access to the value.
@functools.wraps(value)
def new_test(self, value=value):
return value(self)
# Copy __dict__ which may contain test metadata
new_test.__dict__ = copy.deepcopy(value.__dict__)
tf = test_failures and test_failures.get(name)
if tf is not None and suffix in tf.suffixes:
skip_func = (
unittest.skip("Skipped!")
if tf.is_skip
else unittest.expectedFailure
)
new_test = skip_func(new_test)
setattr(other_cls, f"{name}_{suffix}", new_test)
if HAS_CPU and not torch.backends.mps.is_available():
class SweepInputsCpuTest(SweepInputs2, TestCase):
gen = InputGen(10, "cpu")
SweepInputsCpuTest.populate()
class CpuTests(TestCase):
common = check_model
device = "cpu"
copy_tests(CommonTemplate, CpuTests, "cpu")
if HAS_CUDA and not TEST_WITH_ASAN:
class SweepInputsCudaTest(SweepInputs2, TestCase):
gen = InputGen(10, "cuda")
SweepInputsCudaTest.populate()
class CudaTests(TestCase):
common = check_model_cuda
device = "cuda"
copy_tests(CommonTemplate, CudaTests, "cuda")
class TritonCodeGenTests(TestCase):
from torch._inductor.triton_heuristics import CachingAutotuner
class NoOpCompilerBackend:
def __init__(self):
self.example_args = None
self.model = None
def noop_backend(
self,
model_: torch.fx.GraphModule,
example_inputs_: typing.List[torch.Tensor],
):
"""
The Noop backend does not compile the fx graph it is given.
Instead, it transforms the fx graph so that its functions are
aten operations. It then saves this graph.
"""
from torch._functorch.aot_autograd import Interpreter
from torch._inductor.decomposition import select_decomp_table
from torch._subclasses import FakeTensorMode
fake_mode = FakeTensorMode()
def interpret(*args, **kwargs):
return Interpreter(model_).run(*args[0:], **kwargs)
fake_flat_tensor_args = [
fake_mode.from_tensor(x) for x in example_inputs_
]
fw_module = make_fx(interpret, select_decomp_table())(
*fake_flat_tensor_args
)
self.model = fw_module
self.example_args = fake_flat_tensor_args
return lambda x: example_inputs_
def get_kernels(self, fn, args) -> typing.List[CachingAutotuner]:
from torch._inductor.debug import DebugContext
from torch._inductor.graph import GraphLowering
from torch._inductor.virtualized import V
cxt = TritonCodeGenTests.NoOpCompilerBackend()
torch._dynamo.optimize(backend=cxt.noop_backend)(fn)(*args)
graph = GraphLowering(cxt.model)
graph.num_static_inputs = 0
kernels = []
with V.set_graph_handler(graph), V.set_debug_handler(DebugContext()):
graph.run(*(cxt.example_args))
mod = graph.compile_to_module()
for val in mod.__dict__.values():
if isinstance(
val, torch._inductor.triton_heuristics.CachingAutotuner
):
kernels.append(val)
return kernels
def test_divisibile_by_16_covers_numel_args(self):
torch._dynamo.reset()
def fn(a: torch.Tensor) -> torch.Tensor:
return torch.sum(a)
kernels = self.get_kernels(fn, [torch.randn([256, 256], device="cuda")])
self.assertTrue(len(kernels) == 2, "SUM should result in two kernels")
# kernel0 reduces from 256 to (xnumel=8, rnumel=8192), which means it reduces 256 by 256 into an array of
# size 8 by accumulating 8192 elements at once note that rnumel is equal to 512 * 16, so rnumel which is
# at slot 3 should be in the divisible by 16 descriptor
arguments_that_are_divisible_by_16_in_kernel0 = (
kernels[0].meta["configs"][0].divisible_by_16
)
self.assertEqual(arguments_that_are_divisible_by_16_in_kernel0, (0, 1, 3))
# kernel1 reduces from 8 elements to a single scalar.
arguments_that_are_divisible_by_16_in_kernel1 = (
kernels[1].meta["configs"][0].divisible_by_16
)
self.assertEqual(arguments_that_are_divisible_by_16_in_kernel1, (0, 1))
torch._dynamo.reset()
def test_optimize_indexing_dtype(self):
def fn(x: torch.Tensor) -> torch.Tensor:
return aten.upsample_bilinear2d.vec(x, None, True, [2.0, 2.0])
fn_opt = torch._dynamo.optimize("inductor")(fn)
inps = [torch.randn(2, 4, 16, 16, device="cuda")]
code = run_and_get_triton_code(fn_opt, *inps)
self.assertTrue("to(tl.int32)" in code)
self.assertFalse("to(tl.int64)" in code)
self.assertEqual(fn_opt(*inps), fn(*inps))
# See https://github.com/pytorch/pytorch/issues/100348
def test_inductor_detach_view(self):
def fn(x: torch.Tensor) -> torch.Tensor:
a = x * 2
return a, a.detach()
fn_opt = torch._dynamo.optimize("inductor")(fn)
inp = torch.ones(2, 2, requires_grad=True, device="cuda")
inp_ref = inp.clone().detach().requires_grad_(True)
out_ref = fn(inp_ref)
out = fn_opt(inp)
out_ref[0].sum().backward()
out[0].sum().backward()
self.assertEqual(inp.grad, inp_ref.grad)
def test_not_materialize_pointwise_reduction(self):
def fn(a, b):
return (a - b).sum(dim=-1).amax(dim=-1)
N = 16
K = 7
fn_opt = torch._dynamo.optimize("inductor")(fn)
inps = [
torch.randn(N, 1, K, device="cuda"),
torch.randn(1, N, K, device="cuda"),
]
code = run_and_get_triton_code(fn_opt, *inps)
self.assertEqual(code.count("tl.store"), 1)
self.assertTrue("out_ptr1" in code)
self.assertFalse("out_ptr0" in code)
self.assertEqual(fn_opt(*inps), fn(*inps))
# Disable constant propagation, so we isolate value range analysis
@patch.object(config, "constant_and_index_propagation", False)
def test_cant_optimize_compute(self):
def ones():
return torch.ones([4], device="cuda")
def suffix(inp):
return (inp.to(torch.int64) + 1).to(torch.float64)
ten = torch.rand([4], device="cuda")
for foo in (
lambda x: x + 2147483657,
lambda x: torch.where(x < 0, ones(), ones() - 2) * (-(2 ** (40))),
lambda x: x + ten,
lambda x: x + ten.sum(),
):
def fn():
return suffix(foo(ones()))
fn_opt = torch._dynamo.optimize("inductor")(fn)
code = run_and_get_triton_code(fn_opt)
# this cannot be optimized away, value too large
self.assertTrue("to(tl.int64)" in code)
self.assertEqual(fn_opt(), fn())
# Disable constant propagation, so we isolate value range analysis
@patch.object(config, "constant_and_index_propagation", False)
def test_optimize_compute(self):
def ones():
return torch.ones([4], device="cuda")
def suffix(inp):
return (inp.to(torch.int64) + 1).to(torch.float64)
for foo in (
lambda x: x + 500,
lambda x: torch.where(x < 0, ones(), ones() - 2) * (-(2 ** (20))),
lambda x: x / 30,
):
def fn():
return suffix(foo(ones()))
fn_opt = torch._dynamo.optimize("inductor")(fn)
code = run_and_get_triton_code(fn_opt)
# this can be optimized away, value too large
self.assertTrue("to(tl.int64)" not in code)
self.assertTrue("to(tl.int32)" in code)
self.assertEqual(fn_opt(), fn())
# Disable index propagation, so the indirect indexing isn't optimized away
@patch.object(config, "constant_and_index_propagation", False)
def test_computed_indirect_mask(self):
def fn(x, n):
tmp = torch.arange(n, device=x.device)
return x[tmp] + 1
x = torch.randn(8, device="cuda")
fn_opt = torch.compile(fn)
code = run_and_get_triton_code(fn_opt, x, 8)
# load should be masked
self.assertTrue("tl.load(in_ptr0 + (tmp0), xmask)" in code)
self.assertEqual(fn(x, 8), fn_opt(x, 8))
def test_kernel_names_descriptive(self):
@torch._dynamo.optimize("inductor")
def fn1(x):
return x.cos().sin()
@torch._dynamo.optimize("inductor")
def fn2(x):
x = torch.mm(x, x)
x = torch.softmax(x, dim=1)
return x
mod = nn.Sequential(
nn.Linear(4, 4),
nn.LayerNorm(4),
nn.ReLU(),
).cuda()
@torch._dynamo.optimize("inductor")
def fn3(x):
return mod(x)
func_and_kernel_aten = [
(fn1, "triton_poi_fused_cos_sin", (torch.randn(8, device="cuda"),)),
(fn2, "triton_poi_fused__softmax", (torch.randn(4, 4, device="cuda"),)),
(
fn3,
"triton_poi_fused_native_layer_norm_relu",
(torch.randn(4, 4, device="cuda"),),
),
]
func_and_kernel_torch = [
(fn1, "triton_poi_fused_cos_sin", (torch.randn(8, device="cuda"),)),
(fn2, "triton_poi_fused_softmax", (torch.randn(4, 4, device="cuda"),)),
(
fn3,
"triton_poi_fused_LayerNorm_ReLU",
(torch.randn(4, 4, device="cuda"),),
),
]
def test_funcs(func_and_kernel):
with torch.no_grad():
for fn, kernel_name, inps in func_and_kernel:
code = run_and_get_triton_code(fn, *inps)
if kernel_name not in code:
print(code)
self.assertTrue(kernel_name in code)
test_funcs(func_and_kernel_aten)
patch.object(config.triton, "descriptive_names", "torch")(test_funcs)(
func_and_kernel_torch
)
@patch.object(config, "profile_bandwidth", True)
def test_bandwidth_profiler(self):
@torch._dynamo.optimize("inductor")
def fn(x):
x = x.cos()
x = x.cos()
x = torch.mm(x, x)
x = x.sin()
x = x.relu()
return x
inp = torch.randn(4, 4, device="cuda")
code = run_and_get_triton_code(fn, inp)
fn(inp)
self.assertTrue("start_graph" in code)
self.assertTrue("end_graph" in code)
def test_split_op_with_sym(self):
def fn(x: torch.Tensor) -> torch.Tensor:
# split(tensor, sympy.Integer), split(tensor, sympy.Expr)
return torch.split(x, x.shape[0]), torch.split(x, x.shape[0] // 2)
for dynamic_shapes in [True, False]:
with torch._dynamo.config.patch(dynamic_shapes=dynamic_shapes):
torch._dynamo.reset()
fn_opt = torch._dynamo.optimize("inductor", dynamic=dynamic_shapes)(
fn
)
inps = torch.randn([5, 5])
fn_opt(inps)
@skipIfRocm
def test_indirect_device_assert(self):
dir_path = os.path.dirname(os.path.realpath(__file__))
test_path = os.path.join(dir_path, "indirect_assert_helper.py")
fns = ("first_arg", "store", "second_arg", "same_pm_one", "same_pp_one")
for fn, ndims, dyn_shape in itertools.product(fns, (2, 3), (True, False)):
proc = subprocess.Popen(
[
sys.executable,
test_path,
fn,
str(ndims),
str(dyn_shape),
"False",
],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
)
stderr = proc.communicate()[1]
self.assertTrue(
any(
"index out of bounds" in err.decode("utf-8")
for err in stderr.splitlines()
),
f"{fn}, {ndims}, {dyn_shape}, False",
)
proc = subprocess.Popen(
[sys.executable, test_path, "first_arg", "2", "False", "True"],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
)
stderr = proc.communicate()[1]
self.assertTrue(
any(
"index out of bounds" in err.decode("utf-8")
for err in stderr.splitlines()
),
"first_arg 2 False True",
)
class RNNTest(TestCase):
class Model(torch.nn.Module):
def __init__(self):
super().__init__()
self.gru = torch.nn.GRU(16, 16, batch_first=True)
def forward(self, x):
return self.gru(x)
def test_rnn_compile_safe(self):
device = torch.device("cuda")
model = RNNTest.Model().to(device)
model = torch._dynamo.optimize("inductor")(model)
x = torch.rand(1024, 20, 16).to(device)
model(x)
if HAS_CPU:
class TestFull(TestCase):
def test_full_dtype(self):
pytypes = (
bool,
int,
float,
# TODO: Triton's JITFunction._type_of has no support for complex
# complex,
)
dtypes = (
torch.bool,
torch.int32,
torch.int64,
torch.float32,
torch.float64,
None,
# torch.complex64,
# torch.complex128,
)
def fn(pytype, dtype):
if pytype is bool:
fill_value = True
elif pytype is int:
fill_value = 42
elif pytype is float:
fill_value = 42.0
else:
raise AssertionError(f"Unexpected Python type: {pytype}")
return torch.full(
(4, 6), fill_value, dtype=dtype, device=torch.device("cpu")
)
fn_opt = torch._dynamo.optimize("inductor")(fn)
for pytype, dtype in itertools.product(pytypes, dtypes):
with enable_python_dispatcher():
with torch.no_grad():
ret_opt = fn_opt(pytype, dtype)
self.assertEqual(ret_opt, fn(pytype, dtype))
if __name__ == "__main__":
from torch._dynamo.test_case import run_tests
if HAS_CPU or HAS_CUDA:
run_tests(needs="filelock")
| [
"pytorchmergebot@users.noreply.github.com"
] | pytorchmergebot@users.noreply.github.com |
7ea220eeabb2909756fb44da3a87f1f7cf3381a6 | 64f0346472dd6efd2cb53ab4558cff240691be5f | /jobv2/process.py | 7128dcacaaa09d12abba7ce59af2e9c1e5e550b9 | [
"MIT"
] | permissive | broy2808/Jobwebsite | fd192c4a009f61a7ea34bcb188b223fc5fece7bd | 68a41645e4a3f8750aa01b7c522d9e5128796692 | refs/heads/master | 2022-11-03T04:49:34.151690 | 2020-06-09T04:00:33 | 2020-06-09T04:00:33 | 268,330,786 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,571 | py | import csv
import json
import os, sys
from flask import Flask
import json
import pandas as pd
import numpy as np
import re
import nltk
import gensim
from nltk.tokenize import word_tokenize, sent_tokenize
import time
app = Flask(__name__)
app.config["DEBUG"] = True
jobs = pd.read_csv("monster_com-job_sample.csv")
jobs = (jobs.drop(["job_board", "has_expired","date_added", "country", "country_code", "job_type","page_url","salary","sector","uniq_id"],
axis='columns'))
jobs=jobs[jobs['location'].apply(lambda x: len(x)<20)]
jobs=jobs.dropna()
jobs=jobs.iloc[:10000]
p = re.compile(r'[^\w\s,.#:]+')
jobs['job_description'] = [p.sub('', x) for x in jobs['job_description'].tolist()]
def get_data():
data=jobs.to_dict('records')
return data
def preprocess_jobs(file1):
file_docs=[]
for val in file1:
file_docs.append(val[0])
#Tokenize words and create dictionary
gen_docs = [[w.lower() for w in word_tokenize(text)]
for text in file_docs]
dictionary = gensim.corpora.Dictionary(gen_docs)
dictionary.save('workdir/dictionary.index')
# with open('data.txt', 'w') as outfile:
# json.dump(dict(dictionary), outfile)
#Create a bag of words
corpus = [dictionary.doc2bow(gen_doc) for gen_doc in gen_docs]
#TFIDF
tf_idf = gensim.models.TfidfModel(corpus)
tf_idf.save('workdir/tf_idf.index')
#Creating similarity measure object
sims = gensim.similarities.Similarity('workdir/',tf_idf[corpus],
num_features=len(dictionary))
print(sims)
sims.save('workdir/jobs.index')
def compareresumejob(file1,file2_docs):
sims = gensim.similarities.Similarity.load('workdir/jobs.index')
dictionary=gensim.corpora.Dictionary.load('workdir/dictionary.index')
tf_idf = gensim.models.TfidfModel.load('workdir/tf_idf.index')
#Create Query Document
query_doc = [w.lower() for w in word_tokenize(file2_docs)]
query_doc_bow = dictionary.doc2bow(query_doc)
query_doc_tf_idf = tf_idf[query_doc_bow]
print('Comparing Result:', sims[query_doc_tf_idf])
final=[]
index=1
for val in sims[query_doc_tf_idf]:
if val>0.1:
final.append(int(index))
index+=1
print(len(final),len(sims[query_doc_tf_idf]))
return final
###########################################
| [
"noreply@github.com"
] | broy2808.noreply@github.com |
8fc796c4207a429c4194499d77d7d57bc8fc7056 | 7a95770805a0118285cd2bf65583c4b496b5dfe4 | /build/mine_detection/catkin_generated/pkg.develspace.context.pc.py | dc3c39d8268aa31472001073bfb98b2c67174f06 | [] | no_license | DS3a/SLAM_research | 5da83a2ea3f997e28b6124e18cb8721305f553e9 | 26aa447bba517afe916fa4a1ff65b1856fe34c25 | refs/heads/master | 2023-04-03T18:43:11.133547 | 2021-04-09T11:47:11 | 2021-04-09T11:47:11 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 378 | py | # generated from catkin/cmake/template/pkg.context.pc.in
CATKIN_PACKAGE_PREFIX = ""
PROJECT_PKG_CONFIG_INCLUDE_DIRS = "".split(';') if "" != "" else []
PROJECT_CATKIN_DEPENDS = "".replace(';', ' ')
PKG_CONFIG_LIBRARIES_WITH_PREFIX = "".split(';') if "" != "" else []
PROJECT_NAME = "mine_detection"
PROJECT_SPACE_DIR = "/home/d33p/SLAM_research/devel"
PROJECT_VERSION = "0.0.0"
| [
"deepesh.padala02@gmail.com"
] | deepesh.padala02@gmail.com |
628626cfcec0c0e5e8e8d63c97842fcef1e99527 | c9339f45f5397d00fc718d9fbec93b32691bb10a | /knnClasifier.py | 5ee516ef298d512599d42f123e723ee97b0f8276 | [] | no_license | michaelm396/Music-Classifier--CUDA- | 30246e7e28c23a0a05989fe71816e8fa92eb8fd1 | 15ccf18443c4cddbf4d08900a68ac22af296c95d | refs/heads/master | 2020-05-20T08:56:26.525655 | 2019-05-15T19:29:20 | 2019-05-15T19:29:20 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,727 | py | import math
class point:
def __init__(self):
self.coords = []
self.classification = ""
def euclidean_distance(p1,p2):
totalSum = 0
for i in range(len(p1)):
totalSum += pow(p1[i]-p2[i],2)
return math.sqrt(totalSum)
"""
train and test are a list of lists, where each list is a series of float coordinates
i.e. x,y,z,etc. followed by a class (string)
"""
def knn(train,test,k):
#take in train data into list of classes
parsedTrain = []
for i in range(len(train)):
p = point()
p.classification = train[i][len(train[i])-1]
p.coords = train[i][:len(train[i])-1]
parsedTrain += [p]
correctNumber = 0
totalNumber = len(test)
outputList = []
for i in range(len(test)):
currPoint = test[i][:len(test[i])-1]
currClass = test[i][len(test[i])-1] #for error calculation
#construct a dictionary mapping classes to the closest k points for that class
classToKdistances = dict()
for p in parsedTrain:
#calculate euclidean distance beween two points
dist = euclidean_distance(currPoint,p.coords)
#update classToKdistances mainatining sorted arrays
if p.classification in classToKdistances:
if (len(classToKdistances[p.classification]) < k):
idx = 0
L = classToKdistances[p.classification]
while (idx < len(L) and dist < L[idx]):
idx += 1
classToKdistances[p.classification] = L[:idx] + [dist] + L[idx:]
else:
L = classToKdistances[p.classification]
if dist < L[0]:
idx = 1
while (idx < len(L) and dist < L[idx]):
idx += 1
classToKdistances[p.classification] = L[1:idx] + [dist] + L[idx+1:]
else:
classToKdistances[p.classification] = [dist]
#find closest class to this point
bestSum = None
bestClass = None
for c in classToKdistances:
currSum = sum(classToKdistances[c])
if (bestSum == None or currSum < bestSum):
bestSum = currSum
bestClass = c
#if it's correctly classified record it
if bestClass == currClass:
correctNumber += 1
outputList += [(currClass,bestClass)]
print(correctNumber/totalNumber)
return outputList
#testTrain = [[0,1,1,"A"],[0,2,1,"A"],[5,5,1,"B"],[4,6,1,"B"],[1,2,1,"B"],[4,4,1,"A"]]
#testTest = [[0,0,1,"A"],[7,7,1,"B"],[3,3,1,"A"]]
#print(knn(testTrain,testTest,2))
| [
"ecompton@andrew.cmu.edu"
] | ecompton@andrew.cmu.edu |
59207d162557a901209ecd782fee3bedecf7978f | 7ad20654e9fd004717990c9263bda2d4a70ad66c | /PythonInput.py | 65ca493d62a7e419511e1b90d4175ba8f430ae48 | [] | no_license | nareshshah139/see-click-predict | 1fa1c2a0bd4ba5a3557f3f00824782ee42e14522 | 9924fa08cdbe219393d82e18fbe73b278468b0cb | refs/heads/master | 2021-01-16T20:45:39.040405 | 2013-11-09T16:05:22 | 2013-11-09T16:05:22 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,475 | py | # -*- coding: utf-8 -*-
"""
Spyder Editor
This temporary script file is located here:
C:\Users\Standard User\.spyder2\.temp.py
"""
import numpy as np
import csv
import time
from sklearn import cross_validation
from sklearn.metrics import make_scorer
traindata = []
file_name = "C:/Users/Standard User/Downloads/train.csv"
reader = csv.DictReader(open(file_name, 'rb'), delimiter=',', quotechar='"')
for row in reader:
traindata.append(row)
for sub in traindata:
for key in sub:
if key == 'id' or key == 'num_votes' or key == 'num_comments' or key == 'num_views':
sub[key] = int(sub[key])
elif key == 'latitude' or key =='longitude':
sub[key] = float(sub[key])
elif key == 'created_time':
sub[key] = time.mktime(time.strptime(sub[key], "%Y-%m-%d %H:%M:%S")) # make time into datetime (float)
testdata = []
file_name = "C:/Users/Standard User/Downloads/test.csv"
reader = csv.DictReader(open(file_name, 'rb'), delimiter=',', quotechar='"')
for row in reader:
testdata.append(row)
for sub in testdata:
for key in sub:
if key == 'id' or key == 'num_votes' or key == 'num_comments' or key == 'num_views':
sub[key] = int(sub[key])
elif key == 'latitude' or key =='longitude':
sub[key] = float(sub[key])
elif key == 'created_time':
sub[key] = time.mktime(time.strptime(sub[key], "%Y-%m-%d %H:%M:%S"))
print testdata[id]
| [
"nareshshah139@gmail.com"
] | nareshshah139@gmail.com |
5f6dbfea0ad91441a41853c05c0ac8568fa8b357 | 7aeb920de21547a1d9c714b029bbf3a9e7df449e | /examples/stdin-plot.py | fba6350b39f32c8f2c46e973c5aa79d5162a2eed | [
"BSD-2-Clause"
] | permissive | ft/chip-remote | f8ac5a2d7597d24f44ac287836be3422a32283d4 | 2a64df611214f7e3eb55d4ead76e270351158cdb | refs/heads/master | 2023-04-30T08:38:16.483240 | 2023-01-05T04:01:44 | 2023-01-05T04:01:44 | 117,028,633 | 2 | 1 | null | null | null | null | UTF-8 | Python | false | false | 2,002 | py | #!/usr/bin/python3
import collections
import sys
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from matplotlib import style
from matplotlib.lines import Line2D
from threading import Thread
style.use('dark_background')
#style.use('ggplot')
figure = plt.figure()
timedomain = figure.add_subplot(2,1,1)
spectrum = figure.add_subplot(2,1,2)
tdline = Line2D([], [], color='red', linewidth=2)
fdline = Line2D([], [], color='red', linewidth=2)
timedomain.add_line(tdline);
spectrum.add_line(fdline);
timedomain.set_xlim(1, 2200)
timedomain.set_ylim(-100, 100)
spectrum.set_xlim(1, 1100)
spectrum.set_ylim(-70, 0)
# Use a Deque with limited size as a FIFO. This implementation drops old data
# on overflow. Exactly what we need.
fifo = collections.deque(maxlen = 10)
def readData():
while True:
tmp = sys.stdin.readline().strip().split(" ")
data = np.array(tmp, dtype=np.double)
#print("DataSize:", len(data))
fifo.append(data)
def init():
return fdline,tdline
def update(frame):
if len(frame) == 0:
#print("Nop")
return tdline,fdline
frame = frame - np.mean(frame)
n = len(frame)
if n != 2200:
print("python: ", n)
xs = list(range(1, n + 1))
windowed = np.hanning(n) * frame
fd = np.multiply(20, np.log10(np.abs(np.fft.fft(windowed)))) - 100
n = int(len(fd) / 2)
fd = fd[0:n]
fs = list(range(1, n + 1))
tdline.set_data(xs, frame)
fdline.set_data(fs, fd)
return tdline,fdline
def fetch():
while True:
if len(fifo) == 0:
yield []
else:
yield fifo.popleft()
reader = Thread(target = readData)
reader.start()
ani = animation.FuncAnimation(fig = figure,
func = update,
frames = fetch,
interval = 80,
repeat = False,
blit = True)
plt.show()
| [
"ft@bewatermyfriend.org"
] | ft@bewatermyfriend.org |
11674a3f0d3e56f5156c92dbc2833e200511d2f2 | a38180435ac5786185c0aa48891c0aed0ab9d72b | /S4/S4 Library/simulation/situations/complex/single_job_situation.py | 567ee8821eebf3d57e66f878dfe22edeb8aac7d7 | [
"CC-BY-4.0"
] | permissive | NeonOcean/Environment | e190b6b09dd5dbecba0a38c497c01f84c6f9dc7d | ca658cf66e8fd6866c22a4a0136d415705b36d26 | refs/heads/master | 2022-12-03T13:17:00.100440 | 2021-01-09T23:26:55 | 2021-01-09T23:26:55 | 178,096,522 | 1 | 1 | CC-BY-4.0 | 2022-11-22T20:24:59 | 2019-03-28T00:38:17 | Python | UTF-8 | Python | false | false | 1,366 | py | from role.role_state import RoleState
from sims4.tuning.tunable import TunableTuple
from situations.situation import Situation
from situations.situation_complex import SituationComplexCommon, SituationState, SituationStateData
from situations.situation_job import SituationJob
class SingleJobSituation(SituationComplexCommon):
INSTANCE_TUNABLES = {'job': TunableTuple(description='\n The job and role which the career Sim is placed into.\n ', situation_job=SituationJob.TunableReference(description='\n A reference to a SituationJob that can be performed at this Situation.\n '), role_state=RoleState.TunableReference(description='\n A role state the Sim assigned to the job will perform.\n '))}
REMOVE_INSTANCE_TUNABLES = Situation.NON_USER_FACING_REMOVE_INSTANCE_TUNABLES
@classmethod
def _states(cls):
return (SituationStateData(1, SingleJobSituationState),)
@classmethod
def _get_tuned_job_and_default_role_state_tuples(cls):
return [(cls.job.situation_job, cls.job.role_state)]
@classmethod
def default_job(cls):
return cls.job.situation_job
def start_situation(self):
super().start_situation()
self._change_state(SingleJobSituationState())
class SingleJobSituationState(SituationState):
pass
| [
"40919586+NeonOcean@users.noreply.github.com"
] | 40919586+NeonOcean@users.noreply.github.com |
a97b40795c487fc81e1ded147c4ddb7ea130c1e6 | 43277c24ed4d6fffff2f59b9a28c01e52f4bbc5c | /medium/05-division.py | b8cfaa714c5b578fcdcfcadbbd22eff796047ac6 | [] | no_license | ovidiucs/coderbyte_practice | 10daf66c49c42bb4e8f5058c74f300f08644362f | 0de0700e17bd8bd5f3cbdc711c7548608cc25fde | refs/heads/master | 2021-01-13T14:05:08.699330 | 2015-05-21T21:20:52 | 2015-05-21T21:20:52 | 34,564,589 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 261 | py | def Division(num1,num2):
while num2:
num1, num2 = num2, num1%num2
return num1
# keep this function call here
# to see how to enter arguments in Python scroll down
print Division(raw_input())
# i stole this from gcd tbh
| [
"ovidiu.ctin@gmail.com"
] | ovidiu.ctin@gmail.com |
d99252251a452ae5cb1e56c7893d3eaff3940ebb | 86c521c30800d222c5ff13ef16bbdfc340538651 | /dga_classifier/dga_genarator/ramdo.py | 65b45a6ca5f892d283f6a89c9c782399f98f92ff | [] | no_license | sadekyo1712/DGA_PROJECT | b4e2aa0d020102779c0cc0d5e575fd4dbcca09c6 | ccb1ef78357a931a3ef8c6edc4a6e1a3c47b48ec | refs/heads/master | 2021-01-21T12:16:55.834068 | 2017-06-19T04:15:30 | 2017-06-19T04:15:30 | 91,784,086 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,380 | py | # Bui Duc Hung - KSCLC HTTT&TT K57 - BKHN - 5/2017
# DGA Classify Project
# Ramdo DGA
def generate_domain(seed_num, domain_iterator, length=0x10, add_tld=False):
xor1 = 0
sh1 = seed_num << 1
domain_iterator += 1
step1 = domain_iterator * sh1
# step1b = domain_iterator * seed_num
domain_iterator -= 1
iter_seed = domain_iterator * seed_num
imul_edx = iter_seed * 0x1a
xor1 = step1 ^ imul_edx
domain_length = 0
dom = ''
while domain_length < length:
# xor1_divide = xor1 / 0x1a
xor1_remainder = xor1 % 0x1a
xo1_rem_20 = xor1_remainder + 0x20
xo1_step2 = xo1_rem_20 ^ 0xa1
dom_byte = 0x41 + (0xa1 ^ xo1_step2)
dom += chr(dom_byte)
imul_iter = domain_length * step1
imul_result = domain_length * imul_iter
imul_1a = 0x1a * imul_result
xor2 = xor1 ^ imul_1a
xor1 = xor1 + xor2
domain_length += 1
domain_iterator += 1
if add_tld:
return dom + ".org", domain_iterator
return dom, domain_iterator
def generate_domains(num_domains, seed_num=5, length=0x10):
domains = []
domain_iterator = 0
for i in range(num_domains):
domain, domain_iterator = generate_domain(seed_num, domain_iterator, length)
domains.append(domain)
return domains
# import ramdo
# ramdo.generate_domains(10, 5)
| [
"buiduchung.bkhn@gmail.com"
] | buiduchung.bkhn@gmail.com |
d48f0c7ea09c15af2f4f83c2c86b83a4bcd65bd0 | 3c818d763c490efba034699840eb4846473deea5 | /ch13/test.py | c77ee6e9a8fcf08cdb00f842dd79b311cead2eb3 | [] | no_license | dvansoye/python-class | 17f3a6bed6eeb5b7aee5f329648c972872c05bfc | 084cebf4ecb8e841355930b920a90bcb4f16478b | refs/heads/master | 2020-06-11T12:51:15.331662 | 2016-12-08T20:52:37 | 2016-12-08T20:52:37 | 75,662,532 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 889 | py | import urllib
import json
serviceurl = 'http://maps.googleapis.com/maps/api/geocode/json?'
# serviceurl = 'http://python-data.dr-chuck.net/geojson?'
while True:
address = raw_input('Enter location: ')
if len(address) < 1 : break
url = serviceurl + urllib.urlencode({'sensor':'false', 'address': address})
print 'Retrieving', url
uh = urllib.urlopen(url)
data = uh.read()
print 'Retrieved',len(data),'characters'
try: js = json.loads(str(data))
except: js = None
if 'status' not in js or js['status'] != 'OK':
print '==== Failure To Retrieve ===='
print data
continue
print json.dumps(js, indent=4)
lat = js["results"][0]["geometry"]["location"]["lat"]
lng = js["results"][0]["geometry"]["location"]["lng"]
print 'lat',lat,'lng',lng
location = js['results'][0]['formatted_address']
print location | [
"darren@vansoye.com"
] | darren@vansoye.com |
f8a3b210c29c39636d60249712c8a5fd55b3af95 | 6eed0aefcdeedece626d730ac5d6490a5672f578 | /goal/migrations/0007_auto_20200510_1915.py | 83f99f0645bdf3cdb5f9fae81300dd67268da094 | [
"MIT"
] | permissive | ameraibrahim-dev/penny-pincher | 979b576a4c534a4ee8aef35173e442c90f0120ca | da2eb90c97967556afe5d813e3591f8c71937037 | refs/heads/master | 2023-04-06T07:12:49.006880 | 2020-05-26T14:08:56 | 2020-05-26T14:08:56 | 357,151,012 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 432 | py | # Generated by Django 3.0.5 on 2020-05-10 11:15
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('goal', '0006_auto_20200424_0258'),
]
operations = [
migrations.AlterField(
model_name='goaltransaction',
name='is_expense',
field=models.BooleanField(choices=[(True, 'Expense'), (False, 'Earning')]),
),
]
| [
"201601067@iacademy.edu.ph"
] | 201601067@iacademy.edu.ph |
552a6ac20d875de22f26821bd6217d0c0330f9e0 | f5f8b5efbdce78ba4afd0fdcee538d6473804be4 | /speed_tests.py | a1805af65934e84e3778c9375e9f73628c4fa12c | [] | no_license | stsievert/pytorch-timing-comparisons | 2b262612c247764d09a3c90af969d0654ddca506 | b3d57fb40fa46faaec49a9a2e7973e147ebf1335 | refs/heads/master | 2021-06-24T21:59:16.053247 | 2020-07-22T15:31:52 | 2020-07-22T15:31:52 | 102,794,551 | 3 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,302 | py | import numpy as np
from torch.nn import MSELoss
import numpy.linalg as LA
import torch
from torch.autograd import Variable
class PyTorch:
def __init__(self, A=None, x=None, y=None, S=None, S_svd=None):
self.A = torch.from_numpy(A)
self.x = torch.from_numpy(x)
self.y = torch.from_numpy(y)
self.S = torch.from_numpy(S)
self.S_svd = torch.from_numpy(S_svd)
self.A_v = Variable(self.A, requires_grad=False)
self.y_v = Variable(self.y, requires_grad=False)
self.x_v = Variable(self.x, requires_grad=True)
def sin(self):
return torch.sin(self.A)
def matmul(self):
return self.A @ self.x
def add(self):
return self.A + self.A
def svd(self):
return torch.svd(self.S_svd, some=True)[1]
def grad(self):
mse = MSELoss()
m = mse.forward(self.A_v @ self.x_v, self.y_v)
if self.x_v.grad is not None:
self.x_v.grad.data.zero_()
m.backward()
return self.x_v.grad
def complex_fn(self):
x = self.x
A = self.A
S = self.S
return np.sin(x) + np.cos(x)*np.sin(S@x) + torch.dot(x, S@x) + np.exp(S@x)
def cumsum(self):
return torch.cumsum(self.A, 0)
def pow(self):
return torch.pow(torch.abs(self.x), 1.5)
class NumPy:
def __init__(self, n, seed=42):
np.random.seed(42)
self.n = n
d = 10 * n
self.x = np.random.randn(n)
self.A = np.random.randn(d, n)
self.y = self.A @ self.x + np.random.randn(d)
self.S = np.random.randn(n, n)
self.S_svd = np.random.randn(500, 500)
def matmul(self):
return self.A @ self.x
def add(self):
return self.A + self.A
def svd(self):
return np.linalg.svd(self.S_svd, full_matrices=False)[1]
def grad(self):
n, d = self.A.shape
return 2 * self.A.T @ (self.A@self.x - self.y) / n
def sin(self):
return np.sin(self.A)
def cumsum(self):
return np.cumsum(self.A, axis=0)
def pow(self):
return np.float_power(np.abs(self.x), 1.5)
def complex_fn(self):
x = self.x
A = self.A
S = self.S
return np.sin(x) + np.cos(x)*np.sin(S@x) + x.T @ S @ x + np.exp(S@x)
| [
"scott@stsievert.com"
] | scott@stsievert.com |
d49063b0831dc862ef4c2807ab25e403c44229cc | 2ddf7403c0cdd7d8a33c32dda3630eefc6dcb0ce | /analysis.py | bb4e9b3718aaef055283723c561d1757894a3b78 | [] | no_license | zhaobo-666/data_Analyst | 853c6c6d8ce84535e8c801337ccd07536af3ff4c | a8f0ae8408f675219741bec2ea97af9a1838a6a4 | refs/heads/main | 2023-07-30T14:09:28.005639 | 2021-09-26T09:03:56 | 2021-09-26T09:03:56 | 397,852,361 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 8,769 | py | import pymysql
import function
"""
公共必要字段
main_name 主卡姓名
main_card 主卡卡号
to_name 对方姓名
to_card 对方卡号
sign 收付标志
money 交易金额
balance 余额
abstract 摘要
级别表 必须在总表中添加批次字段 一级卡号为第一批次主卡号
`批次` = 1
"""
# host ='172.16.2.190'
# user = 'hzdb'
# pwd = 'hzdb@2021'
# db = 'hzdb'
# port = 3306
#函数
# def list_fetchall(sql):
# conn = pymysql.connect(host=host, user=user, passwd=pwd, port=port, db=db)
# cursor = conn.cursor()
# cursor.execute(sql)
# rows = cursor.fetchall()
# row = [item[0] for item in rows]
# cursor.close()
# conn.close()
# return row
#
# def conn_fetchall(sql):
# conn = pymysql.connect(host=host, user=user, passwd=pwd, port=port, db=db)
# cursor = conn.cursor()
# cursor.execute(sql)
# desc = cursor.description
# ob_dict = [dict(zip([col[0] for col in desc],row)) for row in cursor.fetchall()]
# cursor.close()
# conn.close()
# return ob_dict
#
# def conn_exec(sql):
# conn = pymysql.connect(host=host, user=user, passwd=pwd, port=port, db=db)
# cursor = conn.cursor()
# num = cursor.execute(sql)
# cursor.connection.commit()
# cursor.close()
# conn.close()
# return num
#分析结果表字段
table_res = "分析结果表"
#table_name = "总表_去重"
# main_name = "主卡户名"
# main_card = "查询账号"
# to_name = "对方账号姓名"
# to_card = "对方账号卡号"
# sign = "借贷标志"
# money = "金额"
# balance = "余额"
# abstract = "交易摘要"
# limit_number = 20
def analysis(cursor_user, table_name, main_name, main_card, to_name, to_card, sign, money, abstract, limit_number):
#def analysis(cursor_user, **attrs):
# table_name = attrs['table_name']
# main_name = attrs['main_name']
# main_card = attrs['main_card']
# to_name = attrs['to_name']
# to_card = attrs['to_card']
# sign = attrs['sign']
# money = attrs['money']
# abstract = attrs['abstract']
# limit_number = attrs['limit_number']
#创建卡号级别表
create_card_level = "create table if not exists 卡号级别表 (`卡号` varchar(255),`级别` varchar(255))"
print(create_card_level)
function.conn_exec(create_card_level,cursor_user)
sql_1 = "select `%s` from `%s` where `批次`= 1 group by `%s`"%(main_card,table_name,main_card)
cards = function.list_fetchall(sql_1,cursor_user)
for card in cards:
#插入级别表
card_level_sql_1 = "insert into `卡号级别表`(`卡号`,`级别`)values('%s','%s')"%(card,'一级卡号')
print(card_level_sql_1)
function.conn_exec(card_level_sql_1,cursor_user)
# 查询下级卡号
sql_2 = "select `%s` from `%s` where `%s`='%s' and (`%s`= '借' or `%s`= '出') group by `%s`" % (to_card,table_name,main_card,card,sign,sign,to_card)
print(sql_2)
cards_2 = function.list_fetchall(sql_2,cursor_user)
for card_2 in cards_2:
#判断是否是已经调取的卡号
if card_2 in cards:
continue
# 插入级别表
card_level_sql_2 = "insert into `卡号级别表`(`卡号`,`级别`)values('%s','%s')" % (card_2, '二级卡号')
print(card_level_sql_2)
function.conn_exec(card_level_sql_2,cursor_user)
# 查询下级卡号
sql_3 = "select `%s` from `%s` where `%s`='%s'and (`%s`= '借' or `%s`= '出') group by `%s`" % (to_card, table_name, main_card, card_2,sign,sign,to_card)
print(sql_3)
cards_3 = function.list_fetchall(sql_3,cursor_user)
for card_3 in cards_3:
# 判断是否是已经调取的卡号
if card_3 in cards or card_3 in cards_2:
continue
# 插入级别表
card_level_sql_3 = "insert into `卡号级别表`(`卡号`,`级别`)values('%s','%s')" % (card_3, '三级卡号')
print(card_level_sql_3)
function.conn_exec(card_level_sql_3,cursor_user)
# 查询下级卡号
sql_4 = "select `%s` from `%s` where `%s`='%s'and (`%s`= '借' or `%s`= '出') group by `%s`" % (
to_card, table_name, main_card, card_3, sign, sign,to_card)
print(sql_4)
cards_4 = function.list_fetchall(sql_4,cursor_user)
#创建分析结果表
create_res_tab = "create table if not exists 分析结果表 (`户名` varchar(255) DEFAULT NULL,`卡号`" \
" varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,`交易金额`" \
" varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,`标志`" \
" varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,`分析原因`" \
" varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,`账户级别`" \
" varchar(255) DEFAULT NULL) ENGINE=InnoDB DEFAULT CHARSET=utf8"
print(create_res_tab)
function.conn_exec(create_res_tab,cursor_user)
#查询提现
sql_cash = " select `%s`,`%s`,sum(`%s`) as `交易总额`,'现金提现' as `分析原因` from `%s`" \
" where `%s`>10000 and(`%s` like '提现' or `%s` like '现金' or `%s` like '取款' or %s !='其他')"\
%(main_name,main_card,money,table_name,money,abstract,abstract,abstract,sign)
print(sql_cash)
cash_data = function.conn_fetchall(sql_cash,cursor_user)
for cash_da in cash_data:
cash_insert = "insert into `%s` (`户名`,`卡号`,`交易金额`,`分析原因`)values" \
"('%s','%s','%s','%s')"%(table_res,cash_da[main_name],cash_da[main_card],cash_da['交易总额'],cash_da['分析原因'])
print(cash_insert)
function.conn_exec(cash_insert,cursor_user)
#打给公司
sql_company = "select `%s`,`%s`,sum(`%s`) as `交易总额`,'打给公司' as `分析原因` from" \
" `%s`where char_length(`%s`)>4 and `%s`>10000 group by `%s`"%(main_name,main_card,money,table_name,to_name,money,main_card)
print(sql_company)
company_data = function.conn_fetchall(sql_company,cursor_user)
for company_da in company_data:
company_insert = "insert into `%s` (`户名`,`卡号`,`交易金额`,`分析原因`)values" \
"('%s','%s','%s','%s')"%(table_res,company_da[main_name],company_da[main_card],company_da['交易总额'],company_da['分析原因'])
print(company_insert)
function.conn_exec(company_insert,cursor_user)
#交叉账户
sql_max_money = "select ToUser,ToCard,round(sum(sum)/10000,0) as `交易总额`,'交叉账户' as `分析原因`,count(*) as count from " \
"(select `%s` as `FromUser`,`%s` as FromCard,`%s` as ToUser,`%s`" \
" as ToCard, `%s` as Direction,count(*) as count,sum(`%s`) as sum from %s" \
" group by `%s`,`%s`,`%s`,`%s`,`%s`) A group by ToUser,ToCard having count(*)>=3 limit %d"\
%(main_name,main_card,to_name,to_card,sign,money,table_name,main_name,main_card,to_name,to_card,sign,limit_number)
print(sql_max_money)
max_money_data = function.conn_fetchall(sql_max_money,cursor_user)
for max_money_da in max_money_data:
max_money_insert = "insert into `%s` (`户名`,`卡号`,`交易金额`,`分析原因`)values" \
"('%s','%s','%s','%s')"%(table_res,max_money_da['ToUser'],max_money_da['ToCard'],max_money_da['交易总额'],max_money_da['分析原因'])
print(max_money_insert)
function.conn_exec(max_money_insert,cursor_user)
#交易金额较大
sql_relation = "select ToUser,ToCard,round(sum(sum)/10000,0) as `交易总额`,'交易金额较大' as `分析原因`,sum(count) from " \
"(select `%s` as `FromUser`,`%s` as FromCard,`%s` as ToUser," \
"`%s` as ToCard, `%s` as Direction,count(*) as count,sum(`%s`)" \
" as sum from `%s` group by `%s`,`%s`,`%s`,`%s`,`%s`)" \
" A group by ToUser,ToCard order by round(sum(sum)/10000,0) desc limit %d"\
%(main_name,main_card,to_name,to_card,sign,money,table_name,main_name,main_card,to_name,to_card,sign,limit_number)
print(sql_relation)
relation_data = function.conn_fetchall(sql_relation,cursor_user)
for relation_da in relation_data:
relation_insert = "insert into `%s` (`户名`,`卡号`,`交易金额`,`分析原因`)values" \
"('%s','%s','%s','%s')"%(table_res,relation_da['ToUser'],relation_da['ToCard'],relation_da['交易总额'],relation_da['分析原因'])
print(relation_insert)
function.conn_exec(relation_insert,cursor_user)
| [
"2693716410@qq.com"
] | 2693716410@qq.com |
c88bbd34f0f67cb174f84f0b4cff4aa4f6cd855c | 3969f8402eaa015eb850e041e3dede4978ab9a4c | /pkg/eventlet-0.12.1/tests/patcher_psycopg_test.py | 80988e51fdde3eb2a4aa7f68b40ee7bb7f24f738 | [
"MIT"
] | permissive | seewindcn/pycocos2d | e333bf8ae29d8244e6540ed3d39d76d4002e2908 | b88c8c5df127f9bf82f62c8b4365f4babcdee105 | refs/heads/master | 2023-03-07T10:07:47.167364 | 2013-06-03T10:45:19 | 2013-06-03T10:45:19 | 9,958,133 | 18 | 7 | null | 2013-05-14T03:57:47 | 2013-05-09T11:43:46 | C | UTF-8 | Python | false | false | 1,811 | py | import os
from tests import patcher_test, skip_unless
from tests import get_database_auth
from tests.db_pool_test import postgres_requirement
psycopg_test_file = """
import os
import sys
import eventlet
eventlet.monkey_patch()
from eventlet import patcher
if not patcher.is_monkey_patched('psycopg'):
print "Psycopg not monkeypatched"
sys.exit(0)
count = [0]
def tick(totalseconds, persecond):
for i in xrange(totalseconds*persecond):
count[0] += 1
eventlet.sleep(1.0/persecond)
dsn = os.environ['PSYCOPG_TEST_DSN']
import psycopg2
def fetch(num, secs):
conn = psycopg2.connect(dsn)
cur = conn.cursor()
for i in range(num):
cur.execute("select pg_sleep(%s)", (secs,))
f = eventlet.spawn(fetch, 2, 1)
t = eventlet.spawn(tick, 2, 100)
f.wait()
assert count[0] > 100, count[0]
print "done"
"""
class PatchingPsycopg(patcher_test.ProcessBase):
@skip_unless(postgres_requirement)
def test_psycopg_patched(self):
if 'PSYCOPG_TEST_DSN' not in os.environ:
# construct a non-json dsn for the subprocess
psycopg_auth = get_database_auth()['psycopg2']
if isinstance(psycopg_auth,str):
dsn = psycopg_auth
else:
dsn = " ".join(["%s=%s" % (k,v) for k,v, in psycopg_auth.iteritems()])
os.environ['PSYCOPG_TEST_DSN'] = dsn
self.write_to_tempfile("psycopg_patcher", psycopg_test_file)
output, lines = self.launch_subprocess('psycopg_patcher.py')
if lines[0].startswith('Psycopg not monkeypatched'):
print "Can't test psycopg2 patching; it's not installed."
return
# if there's anything wrong with the test program it'll have a stack trace
self.assert_(lines[0].startswith('done'), output)
| [
"none@none"
] | none@none |
ef80df0d6e2fff1d3da47f67487ade05301c42d3 | 1e4d44f67fb66ce65afdaf7dbf64d894576b96c4 | /back/webapp/app.py | 87360c437bdaa02b8ba8bdee0de4e1e5bf462906 | [] | no_license | Dwape/domotics | c5e9040462198e41dd526b2e7b78d7f88e5b114b | 9aa5af170d6216d6b2df21eb5f5e3815569cd92a | refs/heads/master | 2023-01-09T11:07:21.736736 | 2018-12-08T19:03:58 | 2018-12-08T19:03:58 | 144,603,278 | 0 | 0 | null | 2023-01-04T12:46:06 | 2018-08-13T16:06:28 | JavaScript | UTF-8 | Python | false | false | 6,423 | py | from flask import Flask
from flask import request
from flask import session
from flask import flash #Check
from flask import Response
from flask_cors import CORS, cross_origin
import requests
from read_db import get_latest_values
from read_db import connect
from jsonparser import parseList
from jsonparser import parseLatest
from jsonparser import parsePreferences
from weather import get_weather_values
from valueChecker import check_values
from read_db import get_range_values
from logger2 import logValue
app = Flask(__name__)
cors = CORS(app, supports_credentials=True) #May need to remove the supports_credential parameter
app.config['CORS_HEADERS'] = 'Content-Type'
city = 'Pilar'
temp_max = float(28.0)
temp_min = float(22.0)
hum_max = float(50.0)
hum_min = float(5.0)
@app.route("/")
def home():
'''
Default route of the web application.
'''
return "Welcome to domotics!"
# The JSON returned has a list of two elements for all of the values measured.
# The first values is the actual measurement, in its corresponding unit
# The second values can either be 0 or 1
# If the values is 0, then the measurement is within the acceptable range and no changes should be made
# If the values is 1, then the user should be told to ventilate his house.
@app.route("/api/latest")
def values():
'''
Returns a response with the latest values in the database as a json.
A json returned sent to this method would look like this:
{
"datetime": "2008-11-11 13:23:44",
"humidity": [45, 0],
"temperature": [24, -1],
"LPG": [0, 0],
"CO": [0, 0],
"smoke": [0, 0],
"light": [255, 0],
"current_hum": 23,
"current_temp": 26,
"pressure": 100
}
'''
#connect()
weather = get_weather_values(city)
values = get_latest_values()
# Remove the date from the values as it is not used when comparing values
if 'temp_max' in session:
acceptable = check_values(values[1:], weather, session['temp_max'], session['temp_min'], session['hum_max'], session['hum_min'])
else :
acceptable = check_values(values[1:], weather, temp_max, temp_min, hum_max, hum_min)
json = parseLatest(values, acceptable, weather)
return Response(json, mimetype='application/json')
#return json
@app.route("/api/changePreferences", methods=['POST'])
def changePreferences():
'''
Changes the preferences for a user.
A json returned sent to this method would look like this:
{
"temp_max": "28",
"temp_min": "25",
"hum_max": "70",
"hum_min": "30"
}
'''
if request.method == 'POST':
# Check if it gets the json correctly.
json = request.get_json()
# Check if this way of reading the values of the json work.s
session['temp_max'] = json['temp_max']
session['temp_min'] = json['temp_min']
session['hum_max'] = json['hum_max']
session['hum_min'] = json['hum_min']
#session.modified = True
result = parsePreferences(session['temp_max'], session['temp_min'], session['hum_max'], session['hum_min'])
return Response(result, mimetype='application/json')
@app.route("/api/getPreferences")
def getPreferences():
'''
Returns a json with the current user preferences.
A json returned sent to this method would look like this:
{
"temp_max": "28",
"temp_min": "25",
"hum_max": "70",
"hum_min": "30"
}
'''
if 'temp_max' in session:
result = parsePreferences(session['temp_max'], session['temp_min'], session['hum_max'], session['hum_min'])
else:
result = parsePreferences(temp_max, temp_min, hum_max, hum_min)
return Response(result, mimetype='application/json')
@app.route("/api/valuesRange")
def valuesRange():
'''
Returns values between to dates.
Two parameters are required in the url:
form: The starting date
to: The end date
The json returned from this method looks like this:
[{
"datetime": "2008-11-11 13:23:44",
"humidity": [45, 0],
"temperature": [24, -1],
"LPG": [0, 0],
"CO": [0, 0],
"smoke": [0, 0],
"light": [255, 0],
"current_hum": 23,
"current_temp": 26,
"pressure": 100
},
{
"datetime": "2008-11-11 13:23:44",
"humidity": [46, 0],
"temperature": [25, -1],
"LPG": [0, 0],
"CO": [0, 0],
"smoke": [0, 0],
"light": [234, 0],
"current_hum": 22,
"current_temp": 25,
"pressure": 97
}]
'''
#connect()
fromDate = request.args.get('from')
toDate = request.args.get('to')
results = get_range_values(fromDate, toDate)
return Response(parseList(results), mimetype='application/json')
#return parseList(results)
@app.route("/sensor/measurement", methods=['POST'])
def saveValue():
'''
Saves the measurments sent from the sensors in the database.
Several measurments can be sent from a single sensor in a single message. This allows sensors that measure two things at once to work.
The format of the json should be the following:
[{
"type": "temperature",
"value": 24.5
},
{
"type": "humidity",
"value": 54.2
}]
Where "type" is what is being measured and "value" is the value of the measurement.
There are only 6 valid values for type, any other values will be ignored.
These values are "humidity", "temperature", "LPG", "CO", "smoke" and "light"
Please note that the types must be written exacly as shown above or the measurements will be ignored.
'''
if request.method == 'POST':
json = request.get_json()
for measurement in json:
logValue(measurement['type'], measurement['value'])
return "values saved"
# We should check if the connect can be done here so that we don't have to connect to the database everytime we wish to request a value.
if __name__ == "__main__":
connect() # Check if it works and it makes sense to do this here.
app.secret_key = 'key'
app.run(host='0.0.0.0', port=5000, debug=True)
#session['city'] = "Pilar"
session['temp_max'] = float(28.0)
session['temp_min'] = float(22.0)
session['hum_max'] = float(50.0)
session['hum_min'] = float(5.0)
#session.modified = True | [
"eduardo.lalor@ing.austral.edu.ar"
] | eduardo.lalor@ing.austral.edu.ar |
1f6c0cab59a8d7b9739fafe5e329a5095f04557a | 8684708ad9a1ca45039e0cdc8363321820ddd80a | /standardDeviation.py | abf2b22148bcf0362aa7b80bb58d7037f27270f1 | [] | no_license | VivaEcha838/C-105 | c5d9ce2c1467b733eb48ed893fed26ecbbc4e7d8 | dc20aa44a60e87f4f6ec0cad3393c516c38386c4 | refs/heads/main | 2023-06-19T03:33:26.859256 | 2021-07-19T16:53:04 | 2021-07-19T16:53:04 | 387,534,961 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 589 | py | import csv
import math
from os import read
with open("data.csv", newline="") as f:
readfile = csv.reader(f)
file_data = list(readfile)
data = file_data[0]
num = len(data)
total = 0
for x in data:
total = total + int(x)
mean = total/num
print("Mean is :" + str(mean))
squaredList = []
for num in data:
diff = int(num)-mean
diff = diff**2
squaredList.append(diff)
sum = 0
for i in squaredList:
sum = sum + i
result = sum/(len(data)-1)
stddev = math.sqrt(result)
print("Standard Deviation is : " + str(stddev))
| [
"noreply@github.com"
] | VivaEcha838.noreply@github.com |
244b8d258df23eab6cfec4118e70943771b50a1a | 9779f484e06c7fb35eec53403a3105891d80723e | /P1.Alaniz/venv/bin/python-config | 0a4d1447a7201119ca2a95397ce32a449069cca7 | [] | no_license | Man-on-thoughts/P1.Alaniz | ede087a80401df959dd716ea94a332ba00c77381 | a006ce0eeb1f4baf72b052db944162bc6d4cb896 | refs/heads/master | 2021-05-18T10:19:54.252436 | 2020-04-06T04:28:58 | 2020-04-06T04:28:58 | 251,208,219 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,367 | #!/Users/Zach-Alaniz/PycharmProjects/P1.Alaniz/venv/bin/python
import sys
import getopt
import sysconfig
valid_opts = ['prefix', 'exec-prefix', 'includes', 'libs', 'cflags',
'ldflags', 'help']
if sys.version_info >= (3, 2):
valid_opts.insert(-1, 'extension-suffix')
valid_opts.append('abiflags')
if sys.version_info >= (3, 3):
valid_opts.append('configdir')
def exit_with_usage(code=1):
sys.stderr.write("Usage: {0} [{1}]\n".format(
sys.argv[0], '|'.join('--'+opt for opt in valid_opts)))
sys.exit(code)
try:
opts, args = getopt.getopt(sys.argv[1:], '', valid_opts)
except getopt.error:
exit_with_usage()
if not opts:
exit_with_usage()
pyver = sysconfig.get_config_var('VERSION')
getvar = sysconfig.get_config_var
opt_flags = [flag for (flag, val) in opts]
if '--help' in opt_flags:
exit_with_usage(code=0)
for opt in opt_flags:
if opt == '--prefix':
print(sysconfig.get_config_var('prefix'))
elif opt == '--exec-prefix':
print(sysconfig.get_config_var('exec_prefix'))
elif opt in ('--includes', '--cflags'):
flags = ['-I' + sysconfig.get_path('include'),
'-I' + sysconfig.get_path('platinclude')]
if opt == '--cflags':
flags.extend(getvar('CFLAGS').split())
print(' '.join(flags))
elif opt in ('--libs', '--ldflags'):
abiflags = getattr(sys, 'abiflags', '')
libs = ['-lpython' + pyver + abiflags]
libs += getvar('LIBS').split()
libs += getvar('SYSLIBS').split()
# add the prefix/lib/pythonX.Y/config dir, but only if there is no
# shared library in prefix/lib/.
if opt == '--ldflags':
if not getvar('Py_ENABLE_SHARED'):
libs.insert(0, '-L' + getvar('LIBPL'))
if not getvar('PYTHONFRAMEWORK'):
libs.extend(getvar('LINKFORSHARED').split())
print(' '.join(libs))
elif opt == '--extension-suffix':
ext_suffix = sysconfig.get_config_var('EXT_SUFFIX')
if ext_suffix is None:
ext_suffix = sysconfig.get_config_var('SO')
print(ext_suffix)
elif opt == '--abiflags':
if not getattr(sys, 'abiflags', None):
exit_with_usage()
print(sys.abiflags)
elif opt == '--configdir':
print(sysconfig.get_config_var('LIBPL'))
| [
"zachalaniz94@gmail.com"
] | zachalaniz94@gmail.com | |
35553d9c5dd5cafe84cfa94fd0c31fdeb3e4b8b7 | 4fc1037af17efa358be6cd886fcfd67c5272e93e | /httpx/_main.py | 7bd6b90846ee1d61fc636a7c077b09bbec5b947f | [
"BSD-3-Clause"
] | permissive | hugovk/httpx | d7e9f6bd463c22f454f31f4065babb53427bd73f | 43a1c1c8269cf56a016891aead091acbc3408e81 | refs/heads/master | 2023-01-09T08:55:42.929163 | 2022-03-08T10:53:15 | 2022-03-08T10:53:15 | 203,822,426 | 0 | 0 | BSD-3-Clause | 2023-09-11T10:32:59 | 2019-08-22T15:26:18 | Python | UTF-8 | Python | false | false | 15,506 | py | import functools
import json
import sys
import typing
import click
import httpcore
import pygments.lexers
import pygments.util
import rich.console
import rich.markup
import rich.progress
import rich.syntax
import rich.table
from ._client import Client
from ._exceptions import RequestError
from ._models import Response
from ._status_codes import codes
def print_help() -> None:
console = rich.console.Console()
console.print("[bold]HTTPX :butterfly:", justify="center")
console.print()
console.print("A next generation HTTP client.", justify="center")
console.print()
console.print(
"Usage: [bold]httpx[/bold] [cyan]<URL> [OPTIONS][/cyan] ", justify="left"
)
console.print()
table = rich.table.Table.grid(padding=1, pad_edge=True)
table.add_column("Parameter", no_wrap=True, justify="left", style="bold")
table.add_column("Description")
table.add_row(
"-m, --method [cyan]METHOD",
"Request method, such as GET, POST, PUT, PATCH, DELETE, OPTIONS, HEAD.\n"
"[Default: GET, or POST if a request body is included]",
)
table.add_row(
"-p, --params [cyan]<NAME VALUE> ...",
"Query parameters to include in the request URL.",
)
table.add_row(
"-c, --content [cyan]TEXT", "Byte content to include in the request body."
)
table.add_row(
"-d, --data [cyan]<NAME VALUE> ...", "Form data to include in the request body."
)
table.add_row(
"-f, --files [cyan]<NAME FILENAME> ...",
"Form files to include in the request body.",
)
table.add_row("-j, --json [cyan]TEXT", "JSON data to include in the request body.")
table.add_row(
"-h, --headers [cyan]<NAME VALUE> ...",
"Include additional HTTP headers in the request.",
)
table.add_row(
"--cookies [cyan]<NAME VALUE> ...", "Cookies to include in the request."
)
table.add_row(
"--auth [cyan]<USER PASS>",
"Username and password to include in the request. Specify '-' for the password to use "
"a password prompt. Note that using --verbose/-v will expose the Authorization "
"header, including the password encoding in a trivially reversible format.",
)
table.add_row(
"--proxy [cyan]URL",
"Send the request via a proxy. Should be the URL giving the proxy address.",
)
table.add_row(
"--timeout [cyan]FLOAT",
"Timeout value to use for network operations, such as establishing the connection, "
"reading some data, etc... [Default: 5.0]",
)
table.add_row("--follow-redirects", "Automatically follow redirects.")
table.add_row("--no-verify", "Disable SSL verification.")
table.add_row(
"--http2", "Send the request using HTTP/2, if the remote server supports it."
)
table.add_row(
"--download [cyan]FILE",
"Save the response content as a file, rather than displaying it.",
)
table.add_row("-v, --verbose", "Verbose output. Show request as well as response.")
table.add_row("--help", "Show this message and exit.")
console.print(table)
def get_lexer_for_response(response: Response) -> str:
content_type = response.headers.get("Content-Type")
if content_type is not None:
mime_type, _, _ = content_type.partition(";")
try:
return pygments.lexers.get_lexer_for_mimetype(mime_type.strip()).name
except pygments.util.ClassNotFound: # pragma: nocover
pass
return "" # pragma: nocover
def format_request_headers(request: httpcore.Request, http2: bool = False) -> str:
version = "HTTP/2" if http2 else "HTTP/1.1"
headers = [
(name.lower() if http2 else name, value) for name, value in request.headers
]
method = request.method.decode("ascii")
target = request.url.target.decode("ascii")
lines = [f"{method} {target} {version}"] + [
f"{name.decode('ascii')}: {value.decode('ascii')}" for name, value in headers
]
return "\n".join(lines)
def format_response_headers(
http_version: bytes,
status: int,
reason_phrase: typing.Optional[bytes],
headers: typing.List[typing.Tuple[bytes, bytes]],
) -> str:
version = http_version.decode("ascii")
reason = (
codes.get_reason_phrase(status)
if reason_phrase is None
else reason_phrase.decode("ascii")
)
lines = [f"{version} {status} {reason}"] + [
f"{name.decode('ascii')}: {value.decode('ascii')}" for name, value in headers
]
return "\n".join(lines)
def print_request_headers(request: httpcore.Request, http2: bool = False) -> None:
console = rich.console.Console()
http_text = format_request_headers(request, http2=http2)
syntax = rich.syntax.Syntax(http_text, "http", theme="ansi_dark", word_wrap=True)
console.print(syntax)
syntax = rich.syntax.Syntax("", "http", theme="ansi_dark", word_wrap=True)
console.print(syntax)
def print_response_headers(
http_version: bytes,
status: int,
reason_phrase: typing.Optional[bytes],
headers: typing.List[typing.Tuple[bytes, bytes]],
) -> None:
console = rich.console.Console()
http_text = format_response_headers(http_version, status, reason_phrase, headers)
syntax = rich.syntax.Syntax(http_text, "http", theme="ansi_dark", word_wrap=True)
console.print(syntax)
syntax = rich.syntax.Syntax("", "http", theme="ansi_dark", word_wrap=True)
console.print(syntax)
def print_response(response: Response) -> None:
console = rich.console.Console()
lexer_name = get_lexer_for_response(response)
if lexer_name:
if lexer_name.lower() == "json":
try:
data = response.json()
text = json.dumps(data, indent=4)
except ValueError: # pragma: nocover
text = response.text
else:
text = response.text
syntax = rich.syntax.Syntax(text, lexer_name, theme="ansi_dark", word_wrap=True)
console.print(syntax)
else:
console.print(f"<{len(response.content)} bytes of binary data>")
def format_certificate(cert: dict) -> str: # pragma: nocover
lines = []
for key, value in cert.items():
if isinstance(value, (list, tuple)):
lines.append(f"* {key}:")
for item in value:
if key in ("subject", "issuer"):
for sub_item in item:
lines.append(f"* {sub_item[0]}: {sub_item[1]!r}")
elif isinstance(item, tuple) and len(item) == 2:
lines.append(f"* {item[0]}: {item[1]!r}")
else:
lines.append(f"* {item!r}")
else:
lines.append(f"* {key}: {value!r}")
return "\n".join(lines)
def trace(name: str, info: dict, verbose: bool = False) -> None:
console = rich.console.Console()
if name == "connection.connect_tcp.started" and verbose:
host = info["host"]
console.print(f"* Connecting to {host!r}")
elif name == "connection.connect_tcp.complete" and verbose:
stream = info["return_value"]
server_addr = stream.get_extra_info("server_addr")
console.print(f"* Connected to {server_addr[0]!r} on port {server_addr[1]}")
elif name == "connection.start_tls.complete" and verbose: # pragma: nocover
stream = info["return_value"]
ssl_object = stream.get_extra_info("ssl_object")
version = ssl_object.version()
cipher = ssl_object.cipher()
server_cert = ssl_object.getpeercert()
alpn = ssl_object.selected_alpn_protocol()
console.print(f"* SSL established using {version!r} / {cipher[0]!r}")
console.print(f"* Selected ALPN protocol: {alpn!r}")
if server_cert:
console.print("* Server certificate:")
console.print(format_certificate(server_cert))
elif name == "http11.send_request_headers.started" and verbose:
request = info["request"]
print_request_headers(request, http2=False)
elif name == "http2.send_request_headers.started" and verbose: # pragma: nocover
request = info["request"]
print_request_headers(request, http2=True)
elif name == "http11.receive_response_headers.complete":
http_version, status, reason_phrase, headers = info["return_value"]
print_response_headers(http_version, status, reason_phrase, headers)
elif name == "http2.receive_response_headers.complete": # pragma: nocover
status, headers = info["return_value"]
http_version = b"HTTP/2"
reason_phrase = None
print_response_headers(http_version, status, reason_phrase, headers)
def download_response(response: Response, download: typing.BinaryIO) -> None:
console = rich.console.Console()
console.print()
content_length = response.headers.get("Content-Length")
with rich.progress.Progress(
"[progress.description]{task.description}",
"[progress.percentage]{task.percentage:>3.0f}%",
rich.progress.BarColumn(bar_width=None),
rich.progress.DownloadColumn(),
rich.progress.TransferSpeedColumn(),
) as progress:
description = f"Downloading [bold]{rich.markup.escape(download.name)}"
download_task = progress.add_task(
description,
total=int(content_length or 0),
start=content_length is not None,
)
for chunk in response.iter_bytes():
download.write(chunk)
progress.update(download_task, completed=response.num_bytes_downloaded)
def validate_json(
ctx: click.Context,
param: typing.Union[click.Option, click.Parameter],
value: typing.Any,
) -> typing.Any:
if value is None:
return None
try:
return json.loads(value)
except json.JSONDecodeError: # pragma: nocover
raise click.BadParameter("Not valid JSON")
def validate_auth(
ctx: click.Context,
param: typing.Union[click.Option, click.Parameter],
value: typing.Any,
) -> typing.Any:
if value == (None, None):
return None
username, password = value
if password == "-": # pragma: nocover
password = click.prompt("Password", hide_input=True)
return (username, password)
def handle_help(
ctx: click.Context,
param: typing.Union[click.Option, click.Parameter],
value: typing.Any,
) -> None:
if not value or ctx.resilient_parsing:
return
print_help()
ctx.exit()
@click.command(add_help_option=False)
@click.argument("url", type=str)
@click.option(
"--method",
"-m",
"method",
type=str,
help=(
"Request method, such as GET, POST, PUT, PATCH, DELETE, OPTIONS, HEAD. "
"[Default: GET, or POST if a request body is included]"
),
)
@click.option(
"--params",
"-p",
"params",
type=(str, str),
multiple=True,
help="Query parameters to include in the request URL.",
)
@click.option(
"--content",
"-c",
"content",
type=str,
help="Byte content to include in the request body.",
)
@click.option(
"--data",
"-d",
"data",
type=(str, str),
multiple=True,
help="Form data to include in the request body.",
)
@click.option(
"--files",
"-f",
"files",
type=(str, click.File(mode="rb")),
multiple=True,
help="Form files to include in the request body.",
)
@click.option(
"--json",
"-j",
"json",
type=str,
callback=validate_json,
help="JSON data to include in the request body.",
)
@click.option(
"--headers",
"-h",
"headers",
type=(str, str),
multiple=True,
help="Include additional HTTP headers in the request.",
)
@click.option(
"--cookies",
"cookies",
type=(str, str),
multiple=True,
help="Cookies to include in the request.",
)
@click.option(
"--auth",
"auth",
type=(str, str),
default=(None, None),
callback=validate_auth,
help=(
"Username and password to include in the request. "
"Specify '-' for the password to use a password prompt. "
"Note that using --verbose/-v will expose the Authorization header, "
"including the password encoding in a trivially reversible format."
),
)
@click.option(
"--proxies",
"proxies",
type=str,
default=None,
help="Send the request via a proxy. Should be the URL giving the proxy address.",
)
@click.option(
"--timeout",
"timeout",
type=float,
default=5.0,
help=(
"Timeout value to use for network operations, such as establishing the "
"connection, reading some data, etc... [Default: 5.0]"
),
)
@click.option(
"--follow-redirects",
"follow_redirects",
is_flag=True,
default=False,
help="Automatically follow redirects.",
)
@click.option(
"--no-verify",
"verify",
is_flag=True,
default=True,
help="Disable SSL verification.",
)
@click.option(
"--http2",
"http2",
type=bool,
is_flag=True,
default=False,
help="Send the request using HTTP/2, if the remote server supports it.",
)
@click.option(
"--download",
type=click.File("wb"),
help="Save the response content as a file, rather than displaying it.",
)
@click.option(
"--verbose",
"-v",
type=bool,
is_flag=True,
default=False,
help="Verbose. Show request as well as response.",
)
@click.option(
"--help",
is_flag=True,
is_eager=True,
expose_value=False,
callback=handle_help,
help="Show this message and exit.",
)
def main(
url: str,
method: str,
params: typing.List[typing.Tuple[str, str]],
content: str,
data: typing.List[typing.Tuple[str, str]],
files: typing.List[typing.Tuple[str, click.File]],
json: str,
headers: typing.List[typing.Tuple[str, str]],
cookies: typing.List[typing.Tuple[str, str]],
auth: typing.Optional[typing.Tuple[str, str]],
proxies: str,
timeout: float,
follow_redirects: bool,
verify: bool,
http2: bool,
download: typing.Optional[typing.BinaryIO],
verbose: bool,
) -> None:
"""
An HTTP command line client.
Sends a request and displays the response.
"""
if not method:
method = "POST" if content or data or files or json else "GET"
try:
with Client(
proxies=proxies,
timeout=timeout,
verify=verify,
http2=http2,
) as client:
with client.stream(
method,
url,
params=list(params),
content=content,
data=dict(data),
files=files, # type: ignore
json=json,
headers=headers,
cookies=dict(cookies),
auth=auth,
follow_redirects=follow_redirects,
extensions={"trace": functools.partial(trace, verbose=verbose)},
) as response:
if download is not None:
download_response(response, download)
else:
response.read()
if response.content:
print_response(response)
except RequestError as exc:
console = rich.console.Console()
console.print(f"[red]{type(exc).__name__}[/red]: {exc}")
sys.exit(1)
sys.exit(0 if response.is_success else 1)
| [
"noreply@github.com"
] | hugovk.noreply@github.com |
d58ae3c7d5f559290e4ad6aba0e009878635ebe6 | 625daac7e73b98935f9fe93e647eb809b48b712e | /Arcade/Intro/adjacentElementsProduct.py | 07c848e4a7c18445ca0d1d6cf05d6044c620be21 | [] | no_license | aleksaa01/codefights-codesignal | 19b2d70779cc60f62511b6f88ae5d049451eac82 | a57a5589ab2c9d9580ef44900ea986c826b23051 | refs/heads/master | 2022-03-15T04:46:40.356440 | 2019-12-08T15:41:37 | 2019-12-08T15:41:37 | 112,034,380 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 473 | py | def adjacentElementsProduct(arr):
max_pair = arr[0]*arr[1]
for i in range(1, len(arr)-1):
if arr[i]*arr[i+1] > max_pair:
max_pair = arr[i]*arr[i+1]
return max_pair
"""
Given an array of integers, find the pair of adjacent elements that has the
largest product and return that product.
Example
For inputArray = [3, 6, -2, -5, 7, 3], the output should be
adjacentElementsProduct(inputArray) = 21.
7 and 3 produce the largest product.
"""
| [
"some12curious@gmail.com"
] | some12curious@gmail.com |
540dde4f288a6449313300a882ae105675faffcc | 8885e05fab453cd3d3039c1b447642d1cd8b8e94 | /ogrenci/views/ders_views_api.py | e3747e3a7e37e8d8cf3f902429cf183e08d6c985 | [] | no_license | canerturkaslan/bilgi_sistemi | d1ef34a719c7caf66371e4461529f6fc589ceb6e | 84f59c09cc13e4a4e32db894c55df59e2ac4daa8 | refs/heads/develop | 2022-07-30T18:33:12.200161 | 2020-02-26T00:25:57 | 2020-02-26T00:25:57 | 191,894,970 | 2 | 0 | null | 2022-07-06T20:10:31 | 2019-06-14T07:17:02 | Python | UTF-8 | Python | false | false | 727 | py | from ogrenci.models import Dersler
from ogrenci.serializers.ders_serializers import DersSerializer
from rest_framework.mixins import (
CreateModelMixin, ListModelMixin, RetrieveModelMixin, UpdateModelMixin,DestroyModelMixin
)
from rest_framework.viewsets import GenericViewSet
class DersViewSet(GenericViewSet, # generic view functionality
CreateModelMixin, # handles POSTs
RetrieveModelMixin, # handles GETs for 1 bolum
UpdateModelMixin, # handles PUTs and PATCHes
ListModelMixin,
DestroyModelMixin): # handles GETs for many bolum
serializer_class = DersSerializer
queryset = Dersler.objects.all() | [
"canerturkaslan1998@gmail.com"
] | canerturkaslan1998@gmail.com |
e1bb8884a882e8c7368bb60c4c6e5e9f9d4de06b | c4f17d1b75e95e381ffcaa52b044869f09058c1b | /user/models.py | a87ce20d23fd03b4341fed42db5525e28e057967 | [] | no_license | ygnawk/tindle | 837fb2c60e33839a248cea9f670f38f78e5f409f | f1555cf945313bb484c0a1d944a24a5cc2fcf0e6 | refs/heads/master | 2021-07-21T14:39:50.975372 | 2017-10-31T17:10:03 | 2017-10-31T17:10:03 | 103,834,808 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,370 | py |
from django.core.validators import MinValueValidator, MaxValueValidator
from django.contrib.auth.models import User
from django.utils.timezone import now
from django.db import models
class UserInfo(models.Model):
picture = models.ImageField()
user = models.OneToOneField(User)
description = models.TextField(default="")
birthdate = models.DateField()
interest = models.CharField(max_length=6)
gender = models.CharField(max_length=6)
def __str__(self):
return str(f"{self.user}")
class Book(models.Model):
published = models.CharField(max_length=10)
author = models.CharField(max_length=1000)
title = models.CharField(max_length=1000)
isbn = models.CharField(max_length=1000)
imageurl = models.CharField(max_length=1000)
def __str__(self):
return f"{self.title}"
class Preference(models.Model):
modified = models.DateTimeField(auto_now=True)
created = models.DateTimeField(auto_now_add=True)
book = models.OneToOneField(Book, on_delete=models.PROTECT)
user = models.ForeignKey(User, on_delete=models.PROTECT)
rating = models.PositiveIntegerField(validators=[
MinValueValidator(1),
MaxValueValidator(10)
])
def __str__(self):
return f"({self.user.username}, {self.book}, {self.rating})"
| [
"ykwang@wesleyan.edu"
] | ykwang@wesleyan.edu |
5a79c8bda49772b91cfa1c3248a01e40aeae352f | 1dd36942a8eda2073c200d8feebb03b5b146c5e3 | /venv/Scripts/pip3-script.py | 30c72aaaadfd94c85303b98f5a425cfb7589cdc3 | [] | no_license | Sebastian-MG/Aplicacion | e247c8a8c2ae1c4b86098ed00177e035dc1ed666 | 28c47e35bc50e72d2c996e08c2f1aad6e18e92e4 | refs/heads/master | 2022-04-21T10:36:01.325914 | 2020-03-30T23:24:23 | 2020-03-30T23:24:23 | 251,139,284 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 426 | py | #!"C:\Users\sebas\udistri\Sexto\modelos dos\Finaldef\venv\Scripts\python.exe"
# EASY-INSTALL-ENTRY-SCRIPT: 'pip==19.0.3','console_scripts','pip3'
__requires__ = 'pip==19.0.3'
import re
import sys
from pkg_resources import load_entry_point
if __name__ == '__main__':
sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
sys.exit(
load_entry_point('pip==19.0.3', 'console_scripts', 'pip3')()
)
| [
"”sebastianjhon9427@gmail.com”"
] | ”sebastianjhon9427@gmail.com” |
fb3e967778b0b2f2bbbb00bebda8e32374d261fd | c68b2a6ab94ee475cf732f9c85e9e225408e5640 | /orchestrator.py | 05d73548cd9262c1b4f89cdedbc1a4dfc14c8d2c | [] | no_license | Vikram4533/Selfiless-acts | 3974515ca9210ac54a2ad33fe519e92e215299ed | 22885e66c6d78b68b04240c8c0a390a531ce1881 | refs/heads/master | 2020-05-25T02:45:25.386883 | 2019-05-20T07:05:34 | 2019-05-20T07:05:34 | 187,585,676 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 5,288 | py | from flask import Flask, render_template, request, redirect, abort, jsonify
import threading
import requests
import time, signal, sys
import docker
import json
ip = "http://127.0.0.1:"
apis = ['/api/v1/_count',
'/api/v1/_health',
'/api/v1/_crash',
'/api/v1/categories',
'/api/v1/categories/<categoryName>/acts/size',
'/api/v1/categories/<categoryName>/acts',
'/api/v1/categories/<categoryName>',
'/api/v1/acts/count',
'/api/v1/acts/upvote',
'/api/v1/acts/<actId>',
'/api/v1/acts']
app = Flask(__name__)
sem = threading.Semaphore()
containers = []
nexxt = -1
size = 0
tot_reqs = 0
client = docker.from_env()
def getnexxt():
global nexxt, containers, vv
nexxt = (nexxt + 1) % size
return containers[nexxt]["port"]
def startnewcontainer(port, idx):
global client, size, containers
cont = client.containers.run("acts", detach=True, ports={'80/tcp': port})
if idx < size:
containers[idx] = {'id':cont.id, 'port':port}
else:
containers.append({'id':cont.id, 'port':port})
print(client.containers.list())
time.sleep(5)
size += 1
def stopcontainer(idx):
global size, client
client.containers.get(containers[idx]['id']).stop()
size -= 1
def delete():
global containers
print("\ndestroying containers")
for ii, i in enumerate(containers):
stopcontainer(ii)
@app.route('/', defaults={'path': ''})
@app.route('/<path:path>',methods=['POST','GET','DELETE'])
def hello(path):
global apis, size, tot_reqs, sem
path = '/' + path
if (path not in apis) or size == 0:
abort(404)
if ((path != '/api/v1/_health') and (path != '/api/v1/_crash')):
if (tot_reqs == 0):
sem.release()
tot_reqs += 1
port = getnexxt()
if request.method == "POST":
ret = requests.post(ip+str(port)+path)
elif request.method == "GET":
ret = requests.get(ip+str(port)+path)
else:
ret = requests.delete(ip+str(port)+path)
return jsonify(ret.text), ret.status_code
@app.route("/api/v1/acts/upvote",methods=['POST'])
def upvote():
port=getnexxt()
data1=request.data
print(port)
ret = requests.post(ip+str(port)+'/api/v1/acts/upvote',data1)
return ret.text, ret.status_code
@app.route("/api/v1/categories",methods=['GET','POST'])
def categories():
port=getnexxt()
if(request.method=='GET'):
ret = requests.get(ip+str(port)+'/api/v1/categories')
if(ret.status_code==200):
return jsonify(ret.json()), ret.status_code
else:
return ret.text, ret.status_code
else:
data1=request.data
ret = requests.post(ip+str(port)+'/api/v1/categories',data1)
return ret.text, ret.status_code
@app.route("/api/v1/categories/<categoryName1>",methods=['DELETE'])
def sdsds(categoryName1):
port=getnexxt()
ret = requests.delete(ip+str(port)+'/api/v1/categories/'+categoryName1)
return ret.text, ret.status_code
@app.route("/api/v1/categories/<categoryName>/acts",methods=['GET'])
def listacts(categoryName):
port=getnexxt()
st=request.args.get('start')
ed=request.args.get('end')
if(st and ed):
ret = requests.get(ip+str(port)+'/api/v1/categories/'+categoryName+'/acts?start='+st+"&end="+ed)
if(ret.status_code==200):
return jsonify(ret.json()), ret.status_code
else:
return ret.text, ret.status_code
else:
ret = requests.get(ip+str(port)+'/api/v1/categories/'+categoryName+'/acts')
if(ret.status_code==200):
return jsonify(ret.json()), ret.status_code
else:
return ret.text, ret.status_code
@app.route("/api/v1/acts",methods=['GET','POST'])
def upload():
port=getnexxt()
k=request.get_json(force=True)
print(k)
ret = requests.post(ip+str(port)+'/api/v1/acts',data=json.dumps(k))
return ret.text, ret.status_code
@app.route("/api/v1/categories/<categoryName>/acts/size",methods=['GET'])
def sizeacts(categoryName):
port=getnexxt()
ret = requests.get(ip+str(port)+'/api/v1/categories/'+categoryName+'/acts/size')
return ret.text, ret.status_code
@app.route("/api/v1/acts/<actid>",methods=['DELETE'])
def remove(actid):
port=getnexxt()
ret=requests.delete(ip+str(port)+'/api/v1/acts/'+actid)
return ret.text, ret.status_code
def fun1():
global sem, app
sem.acquire()
app.run(host='0.0.0.0', port=80)
def fun2():
global containers, ip
while True:
time.sleep(10)
for c, cont in enumerate(containers):
if requests.get(ip+str(cont['port'])+"/api/v1/_health").status_code != 200:
stopcontainer(c)
startnewcontainer(cont['port'], c)
def fun3():
global tot_reqs, size, sem
sem.acquire()
while True:
time.sleep(120)
if tot_reqs < 20:
while size > 1:
stopcontainer(size-1)
while size < 1:
startnewcontainer(size+8000, size)
elif tot_reqs < 40:
while size > 2:
stopcontainer(size-1)
while size < 2:
startnewcontainer(size+8000, size)
elif tot_reqs < 60:
while size > 3:
stopcontainer(size-1)
while size < 3:
startnewcontainer(size+8000, size)
else:
while size > 4:
stopcontainer(size-1)
while size < 4:
startnewcontainer(size+8000, size)
tot_reqs = 0
sem.release()
def handler(sig, frame):
delete()
sys.exit(0)
if __name__ == "__main__":
signal.signal(signal.SIGINT, handler)
print('press CTRL+C to exit')
startnewcontainer(8000, 0)
thread1 = threading.Thread(target = fun1)
thread2 = threading.Thread(target = fun2)
thread3 = threading.Thread(target = fun3)
thread1.start()
thread2.start()
thread3.start() | [
"noreply@github.com"
] | Vikram4533.noreply@github.com |
c53d46243aa1761e44cb2274480b59c2d86fe3cf | e271ca30215b2e30a2616e00e907592d88588987 | /lib/python3.6/os.py | 7775423c8f818023fca6f7e8d0153d6286e37cfd | [] | no_license | varavind16/flask | 887e3e68170210a905179b4abec76bd515735d53 | 893115466a9a37e5caad603b0de1a62aa126f8eb | refs/heads/master | 2020-06-05T00:00:12.491030 | 2019-06-16T22:23:33 | 2019-06-16T22:23:33 | 192,241,446 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 43 | py | /home/aravind/anaconda3/lib/python3.6/os.py | [
"avenkatramanan@elementsolutions.com"
] | avenkatramanan@elementsolutions.com |
98378fb1a26595b5265cfd64fec5bdb71002b7d7 | 3fb1ed2edc6141a24c486f058ad224727ed4c040 | /download.py | 96adb4cd7858898f5770873a0357b4487b1bea05 | [] | no_license | jzx1230/LittleSpide | ef103c01982719bb6ca91df984560109635d1ec0 | 359b4b7a002216ec16e3da565ead766bd2229cb4 | refs/heads/master | 2020-04-18T17:46:14.504206 | 2015-12-04T09:28:01 | 2015-12-04T09:28:01 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 721 | py | # -*- coding: UTF-8 -*-
import urllib
import uuid
endWithArr = ['.pdf','.html','.doc','.docx','.png','.jpg','.gif','.txt','.xml','.ppt','.xls','.xlsx']
def cbk(a, b, c):
'''回调函数
@a: 已经下载的数据块
@b: 数据块的大小
@c: 远程文件的大小
'''
per = 100.0 * a * b / c
if per > 100:
per = 100
print '%.2f%%' % per
def downloadHtml(url):
fileName = uuid.uuid1().get_hex()
for str in endWithArr:
if url.endswith(str):
fileName = fileName + str
break
else:
fileName = fileName + '.html'
local = '在这里输入你想要保存下载文件的路径/%s' % (fileName)
urllib.urlretrieve(url, local, cbk) | [
"1287662728@qq.com"
] | 1287662728@qq.com |
4a161f3e8d1ea5be4ca6e8b46acb99dc2279a72e | 26ee58b9513ba410d78c3bbb6c43376ef859bbca | /comp_monthly_rmse_pr_thiessen_echam46.py | 2f1ea6d4fb99f84d2271f5fda80ab345c28fe6db | [] | no_license | LeidiniceSilva/pymusf | fb8b480f302593fd107a3159e9636d614138a6c8 | 7f6df348841df1f742227826f26dd27031d03e29 | refs/heads/master | 2023-07-08T17:07:01.490248 | 2023-07-06T01:21:56 | 2023-07-06T01:21:56 | 112,038,727 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 9,939 | py | # -*- coding: utf-8 -*-jmniu8
""" Verification of the precipitation ability of ECHAM46. """
import matplotlib as mpl; mpl.use('Agg')
import netCDF4
import calendar
import os
from datetime import date
from pylab import *
from matplotlib import pyplot as plt
from PyFuncemeClimateTools import ClimateStats as cs
from hidropy.utils.hidropy_utils import basin_dict, create_path
from matplotlib.font_manager import FontProperties
__author__ = "Leidinice Silva"
__email__ = "leidinice.silvae@funceme.br"
__date__ = "04/04/2017"
__description__ = "Verification of the precipitation ability of ECHAM46"
scale = 'monthly'
month = 'jan'
mon = 'jan'
param = 'pr'
period = 'hind8110'
model = "echam46"
home = os.path.expanduser("~")
hidropy_path = "/home/leidinice/documentos/projetos_git_funceme"
print month
print "int"
macros_total = ['amazonas', 'atlantico_leste', 'atlantico_sudeste', 'atlantico_sul', 'doce', 'grande', 'iguacu',
'jacui', 'paraguai', 'paraiba_do_sul', 'parana', 'paranaiba', 'paranapanema', 'parnaiba',
'sao_francisco', 'tiete', 'tocantins', 'uruguai']
macros_inc = ['amazonas', 'atlantico_leste', 'doce', 'grande', 'iguacu', 'jacui', 'paraiba_do_sul', 'parana',
'paranaiba', 'paranapanema', 'sao_francisco', 'tiete', 'tocantins', 'uruguai']
for macro in macros_total:
print macro
folders = os.listdir("{0}/hidropy/hidropy/shapes/basins/".format(hidropy_path))
basins = sorted(basin_dict(micro=True, basin_name=macro))
basin_name = macro
# total
bas_new = []
for bas in basins:
if '_inc' not in(bas):
bas_new.append(bas)
# inc
# bas_new = []
# for bas in basins:
# if '_inc' in (bas):
# bas_new.append(bas)
len_bas = len(bas_new)
CORREL = []
MBE = []
RMSE = []
plot_lines = []
for basin in bas_new:
basin_fullname = basin_dict(basin)[2]
macro_name = basin_dict(basin)[1]
print basin
# open netcdf
link1 = home + "/io/inmet_ana_chirps/calibration/{0}/{1}_thiessen/{2}".format(scale, param, macro_name)
arq1 = "{0}/{1}_{2}_inmet_ana_chirps_obs_19610101_20141231_thiessen_{3}.nc".format(link1, param, scale,
basin_fullname)
data1 = netCDF4.Dataset(arq1)
variable1 = data1.variables[param][:].T
time1 = data1.variables['time']
st1 = variable1[600:648]
st11 = variable1[612:648]
sto_obs1 = []
sto_obs2 = []
sto_obs3 = []
link2 = home + "/io/inmet_ana_chirps/operation/{0}/{1}_thiessen/{2}".format(scale, param, macro_name)
arq2 = "{0}/{1}_{2}_inmet_ana_chirps_obs_20150101_20170228_thiessen_{3}.nc".format(link2, param, scale,
basin_fullname)
data2 = netCDF4.Dataset(arq2)
variable2 = data2.variables[param][:].T
time2 = data2.variables['time']
st2 = variable2[0:24]
st22 = variable2[0:26]
observ = np.full(72, np.nan)
observ[0:48] = st1
observ[48:72] = st2
observa = np.full(62, np.nan)
observa[0:36] = st11
observa[36:62] = st22
sto_obs1.append(observ[1::12])
sto_obs2.append(observ[2::12])
sto_obs3.append(observ[3::12])
# open fcst
sto_sim1 = []
sto_sim2 = []
sto_sim3 = []
link3 = home + "/io/{0}/{1}/{2}/{3}/{4}_thiessen/{5}".format(model, period, mon, scale, param, macro_name)
for year in range(2011, 2017):
start_date = date(year, 12, 31)
new_year = start_date + relativedelta(months=1)
new_year_y = str(new_year)[0:4] + str(new_year)[5:7] + str(new_year)[8:10]
arq3 = "{0}/{1}_{2}_{3}_{4}_fcst_{5}0101_{5}0201_{5}0430_thiessen_{6}.nc".format(link3, param, scale, model,
period, year,
basin_fullname)
data3 = netCDF4.Dataset(arq3)
variable3 = data3.variables[param][:]
time3 = data3.variables['time']
st3 = variable3
sto_sim1.append(st3[0::3])
sto_sim2.append(st3[1::3])
sto_sim3.append(st3[2::3])
# Calculate correlacao, bias and rmse of pr_thiessen
corr1 = np.corrcoef(np.squeeze(sto_obs1), np.squeeze(sto_sim1))
corr2 = np.corrcoef(np.squeeze(sto_obs2), np.squeeze(sto_sim2))
corr3 = np.corrcoef(np.squeeze(sto_obs3), np.squeeze(sto_sim3))
CORR = np.array([round(corr1[0][1], 3), round(corr2[0][1], 3), round(corr3[0][1], 3)])
CORREL.append(CORR)
vies1 = np.nanmean(np.squeeze(sto_sim1) - np.squeeze(sto_obs1))
vies2 = np.nanmean(np.squeeze(sto_sim2) - np.squeeze(sto_obs2))
vies3 = np.nanmean(np.squeeze(sto_sim3) - np.squeeze(sto_obs3))
BIAS = np.array([vies1, vies2, vies3])
MBE.append(BIAS)
rmse1 = cs.compute_rmse(np.squeeze(sto_sim1), np.squeeze(sto_obs1))
rmse2 = cs.compute_rmse(np.squeeze(sto_sim2), np.squeeze(sto_obs2))
rmse3 = cs.compute_rmse(np.squeeze(sto_sim3), np.squeeze(sto_obs3))
ERRO = np.array([rmse1, rmse2, rmse3])
RMSE.append(ERRO)
# print CORREL
# print MBE
# print RMSE
# exit()
# Generating comparative bar of pr thiessen
cmap = plt.cm.gray
fig, ax = plt.subplots(3, figsize=(210, 180))
w = 0.14
CORREL = np.array(CORREL).T
MBE = np.array(MBE).T
RMSE = np.array(RMSE).T
bar1 = len(CORREL[:, 0])
bar1w = w / bar1
bar2 = len(MBE[:, 0])
bar2w = w / bar2
bar3 = len(RMSE[:, 0])
bar3w = w / bar3
x = np.arange(len(CORREL))
y = np.arange(len(MBE))
z = np.arange(len(RMSE))
line_colors = cmap(np.linspace(0, 3))
labels = np.arange(len(bas_new))
teste = []
list_basins = []
objects = ['FEV', 'MAR', 'ABR']
for i in range(len(bas_new)):
list_basins.append(bas_new[i].split('{0}_'.format(basin_name))[1].capitalize())
fig.suptitle(u'Índices: CORRELAÇÃO, MBE e RMSE \n Modelo: {0} / Previsão: {1} - 2011_2016 \n Bacia: {2} - Usinas:'
u' Totais'.format(model.upper(), month.capitalize(), macro_name.capitalize()),
fontsize=250, fontweight='bold')
count = (1 - len_bas * bar1w) / 2
a = CORREL[:, i]
b = ax[0].bar(x + count + i * bar1w, a, bar1w, color=line_colors[i], label=i)
ax[0].set_ylim([-1, 1])
ax[0].set_xlim([0, 3])
ax[0].axhline(y=0, linewidth=1, color='k')
ax[0].text(-0.20, -1.0, u'A)', fontsize=200, fontweight='bold')
ax[0].set_ylabel(u'Correlação', fontsize=200, fontweight='bold')
ax[0].set_xticks([0.5, 1.5, 2.5])
ax[0].set_xticklabels(objects, fontsize=200, fontweight='bold')
c = MBE[:, i]
d = ax[1].bar(y + count + i * bar2w, c, bar2w, color=line_colors[i], label=i)
ax[1].set_xlim([0, 3])
ax[1].set_ylim([-400, 400])
ax[1].axhline(y=0, linewidth=1, color='k')
ax[1].text(-0.20, -400, u'B)', fontsize=200, fontweight='bold')
ax[1].set_ylabel(u'MBE', fontsize=200, fontweight='bold')
ax[1].set_xticks([0.5, 1.5, 2.5])
ax[1].set_xticklabels(objects, fontsize=200, fontweight='bold')
e = RMSE[:, i]
f = ax[2].bar(z + count + i * bar3w, e, bar3w, color=line_colors[i], label=i)
ax[2].set_ylim([0, 400])
ax[2].set_xlim([0, 3])
ax[2].text(-0.20, 0, u'C)', fontsize=200, fontweight='bold')
ax[2].set_ylabel(u'RMSE', fontsize=200, fontweight='bold')
ax[2].set_xticks([0.5, 1.5, 2.5])
ax[2].set_xticklabels(objects, fontsize=200, fontweight='bold')
teste.append(f)
ax[0].axvline(0, color='k')
ax[0].axvline(1, color='#808080')
ax[0].axvline(2, color='#808080')
ax[0].axvline(3, color='k')
ax[0].axhline(-1, color='k')
ax[0].axhline(1, color='k')
ax[1].axvline(0, color='k')
ax[1].axvline(1, color='#808080')
ax[1].axvline(2, color='#808080')
ax[1].axvline(3, color='k')
ax[1].axhline(-400, color='k')
ax[1].axhline(400, color='k')
ax[2].axvline(0, color='k')
ax[2].axvline(1, color='#808080')
ax[2].axvline(2, color='#808080')
ax[2].axvline(3, color='k')
ax[2].axhline(0, color='k')
ax[2].axhline(400, color='k')
ax[0].tick_params(axis='both', which='major', labelsize=160, length=50, width=10, pad=50, labelcolor='k')
ax[0].grid(True, which='major', linestyle='-.', linewidth='5')
ax[1].tick_params(axis='both', which='major', labelsize=160, length=50, width=10, pad=50, labelcolor='k')
ax[1].grid(True, which='major', linestyle='-.', linewidth='5')
ax[2].tick_params(axis='both', which='major', labelsize=160, length=50, width=10, pad=50, labelcolor='k')
ax[2].grid(True, which='major', linestyle='-.', linewidth='5')
font = FontProperties(weight='bold', size=155)
plt.figlegend(teste, list_basins, loc=8, ncol=6, prop=font)
path_out = ('/home/leidinice/documentos/results/{0}/correct_rmse/{1}/{2}/{3}_thiessen/{4}/'
'totais/'.format(model, mon, scale, param, macro_name))
if not os.path.exists(path_out):
create_path(path_out)
plt.savefig(os.path.join(path_out, '{0}_totais_indices_RMSE_{1}_thiessen_{2}_{3}.png'.format(macro_name, param,
model, month)), dpi=25)
plt.close('all')
plt.cla()
| [
"leidinicesilva@gmail.com"
] | leidinicesilva@gmail.com |
0188b54bbf25bf074ae01720f8e7b4e5c34dc20b | ad2704933de4502ae9de91e6d915f9dbe010b446 | /yamagishi/chapter05/knock47.py | 35d17a4e8eaf40fca3503cf4af37d9cd7db8c8df | [] | no_license | tmu-nlp/100knock2017 | 266e68917d8d5a7f5d0c064f1bc2da5fa402a253 | 629bd1155d0fe78cd9302ae9a7cdf0922b778fe7 | refs/heads/master | 2021-01-19T17:36:53.328997 | 2017-07-24T07:09:54 | 2017-07-24T07:09:54 | 88,334,932 | 8 | 2 | null | null | null | null | UTF-8 | Python | false | false | 1,028 | py | from knock41 import Chunk, get_neko_list
for line in get_neko_list():
for chunk in line:
verb = ''
for morph in chunk.get_morphs():
if morph.get_pos() == '動詞':
verb = morph.get_base()
if verb == '':
continue
particle_list = list()
for src in chunk.get_srcs():
src_morph = line[src].get_word_only_morphs()
if len(src_morph) > 0 and src_morph[-1].get_pos() =='助詞':
pair = [src_morph[-1].get_base(), line[src].get_word_only()]
particle_list.append(pair)
if len(particle_list) > 0:
# 中身をlist型にしておかないとpopができない
particle, phrase = list(map(list, zip(*sorted(particle_list))))
if 'を' in particle:
wo_case = phrase.pop(particle.index('を'))
particle.pop(particle.index('を'))
print('{}\t{}\t{}'.format(wo_case + verb, ' '.join(particle), ' '.join(phrase)))
| [
"pfm.harg.0524@gmail.com"
] | pfm.harg.0524@gmail.com |
c6492508982755a4e1e8b20b63f7fa75931cdd05 | fbd4ecf7046171c4e96267c5982c964db54578f5 | /business/p201904/110111_2300/server.py | 0872fb79fab8ceec11b2a306e6bc2a815aee5719 | [] | no_license | Alvin2580du/alvin_py | 6dddcfbfae214694e9f3dafd976101e681f2a66d | 82d3e9808073f2145b039ccf464c526cb85274e3 | refs/heads/master | 2021-05-05T16:01:43.544783 | 2019-10-29T02:23:59 | 2019-10-29T02:23:59 | 117,328,713 | 12 | 2 | null | 2021-03-20T00:06:37 | 2018-01-13T08:51:49 | Python | UTF-8 | Python | false | false | 3,200 | py | import os.path
import tornado.httpserver
import tornado.ioloop
import tornado.options
import tornado.web
from tornado.options import define, options
import sys
from gensim.models.word2vec import Word2Vec
import numpy as np
import jieba
from sklearn.externals import joblib
ports = sys.argv[1]
define("port", default=ports, help="run on the given port", type=int)
# 加载模型
imdb_w2v = Word2Vec.load('w2v_model.pkl')
clf = joblib.load('svm_model.pkl')
# 对每个句子的所有词向量取均值，来生成一个句子的vector
def build_sentence_vector(text, size, imdb_w2v):
vec = np.zeros(size).reshape((1, size))
count = 0.
for word in text:
try:
vec += imdb_w2v[word].reshape((1, size))
count += 1.
except KeyError:
continue
if count != 0:
vec /= count
return vec
# 构建待预测句子的向量
def get_predict_vecs(words, n_dim=300):
train_vecs = build_sentence_vector(words, n_dim, imdb_w2v)
return train_vecs
# 对单个句子进行情感判断
def svm_predict(string):
words = jieba.lcut(string)
words_vecs = get_predict_vecs(words)
result = clf.predict(words_vecs)
if int(result[0]) == 1:
return "positive"
else:
return "negative"
class IndexHandler(tornado.web.RequestHandler):
def get(self):
self.render("index.html")
class UserHandler(tornado.web.RequestHandler):
def post(self):
message = self.get_argument("message")
print("输入的句子是：{}".format(message))
res = svm_predict(message)
self.render("message.html", message="{}的情感极性是：\n{}".format(message, res))
handlers = [
(r"/", IndexHandler),
(r"/user", UserHandler)
]
if __name__ == "__main__":
""" 测试句子
坐牢，怎么可能轻易放过
把携程亲子园所有的老师全部全家处死一个不留
妈呀，光看视频就已经哭的不行，这些人还有没有人性啊，希望法律严惩，给家长们一个交代。
认错已经不是原谅的理由，必须严惩，孩子的伤害是无法弥补的
中国改改法律吧，就是因为他们以前这种幼师犯罪判个一两年就了事，才有这么多人更甚，最少十年以上，严重判死刑，看有几个还敢的
真应该给这些人判死刑啊
真的是心疼到无法呼吸！！！！！啊啊啊啊啊啊妈的比
没有职业道德就不用当幼师，承受不了孩子的吵闹各种调皮就不要当幼师，真的别当幼师，你都没爱心了，何必去当幼师，可怜的孩子遇见你真的是很可怜
打死都不可惜
我也是位母亲，看到这样的视频，真的是很揪心
简直不配做人！简直无法理解！谁招来的这畜生也得负责任吧！不，畜生都比她强！
这种人希望被国家拉黑
"""
template_path = os.path.join(os.path.dirname(__file__), "template")
tornado.options.parse_command_line()
app = tornado.web.Application(handlers, template_path)
http_server = tornado.httpserver.HTTPServer(app)
http_server.listen(options.port)
tornado.ioloop.IOLoop.instance().start()
| [
"ypducdtu@163.com"
] | ypducdtu@163.com |
edf15c92a4b3e7f8eb575d075b92cdebd5a9242b | b12c8cbb13990738aafb5f940784e79c27dc6d7b | /model_creation/CONFIG.py | 6574d6ad3d16c24a5c5bd81ab18d86a777223b57 | [] | no_license | Andre-Schwarz/next_word_prediction | a0d6390416e3a1dd2eaa6de146a5e033ec7afc76 | d219e8c73a5226b862706f3860cd0904272fc731 | refs/heads/main | 2023-06-03T04:13:11.813336 | 2021-06-23T14:51:43 | 2021-06-23T14:51:43 | 378,092,884 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 127 | py | number_of_words = 3
batch_size = 200
hidden_size = 200 #1500
num_epochs = 20 #80
learning_rate = 0.001
learning_rate_decay = 0
| [
"“andre.schwarz@uxma.com”"
] | “andre.schwarz@uxma.com” |
96f84ef4b4488db0ea421b9816cfca89c0adc2ee | 36347bc7d5ca8ecca5d074ecb3a878f8e6c0d04b | /segments/migrations/0006_segment_recalculated_date.py | 7026e5651b1b12a2d4edf4a3e1a5a17173d9209a | [] | no_license | groveco/django-segments | 32711b04519212075ff67f54dbf280b7823df5e8 | af65bada572a8d7eeb66a4da47ce6f0a193b99fd | refs/heads/main | 2023-05-14T06:29:57.268324 | 2023-04-27T17:39:40 | 2023-04-27T17:39:40 | 23,624,819 | 25 | 8 | null | 2023-04-27T17:39:41 | 2014-09-03T14:57:52 | Python | UTF-8 | Python | false | false | 474 | py | # -*- coding: utf-8 -*-
# Generated by Django 1.11.6 on 2019-03-15 03:08
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('segments', '0005_auto_20190314_1502'),
]
operations = [
migrations.AddField(
model_name='segment',
name='recalculated_date',
field=models.DateTimeField(blank=True, null=True),
),
]
| [
"kate@katekligman.com"
] | kate@katekligman.com |
c99f8dacb71f653c117ceab217834b926284254a | a4ba049e9e9232c6ff50fdd271a920d26377c88b | /复制.py | f644bef6edddef48eb3a4eee84da041f57377f4f | [] | no_license | junfeiZTE/pythonCode | e5ab8126c0801eb7c7d39b10fe51ca52fa023c58 | 9be6a2a57188b0eb417525a06fd90fc5580adce9 | refs/heads/master | 2021-04-27T15:21:09.523295 | 2018-02-25T15:19:47 | 2018-02-25T15:19:47 | 122,467,289 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 79 | py | import copy
a=[1,2,3]
b=a
print(id(a))
c=copy.deepcopy(a)
print(id(c))
| [
"noreply@github.com"
] | junfeiZTE.noreply@github.com |
7956236c1a7441e489515f2d21c88dd3e9618992 | baeca56d705aab0325fe6c2fc5fbd0b8c9883303 | /树和图/树/3.py | 6a0a37c040f64fadbbb89d004b6fda298bf29590 | [] | no_license | lixiangwang/SEU---Data-structure-and-algorithm-design | 69411225934636ea791ced494b598d610224b48f | cbc03bff7e885a196dfd6a6a75de112e8b6a3aa5 | refs/heads/master | 2020-11-23T22:46:19.928513 | 2019-12-23T11:06:14 | 2019-12-23T11:06:14 | 227,852,147 | 1 | 1 | null | null | null | null | UTF-8 | Python | false | false | 952 | py | # encoding: utf-8
#from binarytree import Node ##binarytree的Node可以print可视化
class Node(object):
def __init__(self, value):
self.value = value
self.left = None
self.right = None
class Solution:
def __init__(self):
self.ans = 0
def diameterOfBinaryTree(self, root: Node) -> int:
if not root:
return 0
self.depth(root)
return self.ans
def depth(self, root):
if not root:
return 0
left = self.depth(root.left)
right = self.depth(root.right)
if left + right > self.ans:
self.ans = left + right
return 1 + max(left, right)
if __name__ == '__main__':
solution = Solution()
root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.right = Node(4)
root.left.right.left = Node(5)
print('该二叉树的直径为：',solution.diameterOfBinaryTree(root))
| [
"47591862+lixiangwang@users.noreply.github.com"
] | 47591862+lixiangwang@users.noreply.github.com |
e027c29b58af37ee312433c6b3c48aae27a3ce42 | 8d80ccc0708881b4b39ed10287d9611605f6f32c | /db_setup/FillTableScript.py | f2a625adb01d29e3db5ec2389aa61754e532d8b8 | [
"MIT"
] | permissive | durham-abric/comp421-social-network | c85aa5883771bd5381fbdd26370c8f43a2741cc1 | d6d8878f39342349f730b547c7575aeced3d4949 | refs/heads/master | 2020-04-25T18:44:45.546657 | 2019-03-27T03:40:44 | 2019-03-27T03:40:44 | 172,994,412 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 8,093 | py | # Table/View Schema Type Creation time
# ------------------------------- --------------- ----- --------------------------
# ADMINISTERS CS421G43 T 2019-02-25-16.59.47.779186
# COMMENT CS421G43 T 2019-02-25-16.59.46.733057
# CONTAINSTAG CS421G43 T 2019-02-25-16.59.47.470076
# EVENT CS421G43 T 2019-02-25-16.59.46.390286
# FRIENDS CS421G43 T 2019-02-25-16.59.47.298675
# GOINGTO CS421G43 T 2019-02-25-16.59.47.950084
# GROUP CS421G43 T 2019-02-25-16.59.46.219100
# LIKE CS421G43 T 2019-02-25-16.59.48.119889
# MEMBEROF CS421G43 T 2019-02-25-16.59.47.610708
# PAGEOWNER CS421G43 T 2019-02-25-16.59.45.756370
# POST CS421G43 T 2019-02-25-16.59.46.562963
# PRIVATEMESSAGE CS421G43 T 2019-02-25-16.59.47.128806
# TAG CS421G43 T 2019-02-25-16.59.46.958387
# USER CS421G43 T 2019-02-25-16.59.46.012782
import random;
import string;
import itertools;
random.seed(0)
def randomTimeStamp():
year = str(random.randint(2000,2019))
month = "{:02d}".format(random.randint(1,12))
day = "{:02d}".format(random.randint(1,28))
hour = "{:02d}".format(random.randint(0,23))
minute = "{:02d}".format(random.randint(0,59))
sec = "00"#"{:02d}".format(random.randint(0,59))
return "TimeStamp('" + year + "-" + month + "-" + day + "-" + hour + "." + minute + "." + sec +"')"
privacySetting = ["private", "public", "friends"]
PageOwnerIds = []
UserIds = []
EventIds = []
GroupIds = []
PageIds = []
PostIDs = []
TagList = []
CommentIds = []
HashTagList = ["HashTag1", "HashTag2", "HashTag3", "HashTag4", "HashTag5"]
for l in HashTagList:
print("INSERT INTO Tag VALUES('"+ l +"');")
print()
Locations = []
for i in range(3):
Locations.append(''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(80)))
while len(PageOwnerIds) < 10:
oID = random.randint(0, 2 ** 30)
if oID not in PageOwnerIds:
PageOwnerIds.append(oID)
UserIds.append(oID)
desc = ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(150))
privacy = random.choice(privacySetting)
while True:
pageID = random.randint(0, 2 ** 30)
if pageID not in PageIds:
break
PageIds.append(pageID)
username = ''.join(random.choice(string.ascii_uppercase) for _ in range(15))
year = random.randint(1950, 2010)
email = ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(80))
password = ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(80))
print("INSERT INTO PageOwner VALUES(" + str(oID) + ", '" + desc + "', '" + privacy + "', " + str(pageID) + ");")
print("INSERT INTO User VALUES(" + str(oID) + ", '" + username + "', DATE('" +
str(year) + "-01-01'), '" + email + "', '" + password + "');\n")
while len(PageOwnerIds) < 20:
oID = random.randint(0, 2 ** 30)
if oID not in PageOwnerIds:
PageOwnerIds.append(oID)
GroupIds.append(oID)
desc = ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(150))
privacy = random.choice(privacySetting)
while True:
pageID = random.randint(0, 2 ** 30)
if pageID not in PageIds:
break
PageIds.append(pageID)
groupname = ''.join(random.choice(string.ascii_uppercase) for _ in range(45))
creator = random.choice(UserIds)
print("INSERT INTO PageOwner VALUES(" + str(oID) + ", '" + desc + "', '" + privacy + "', " + str(pageID) + ");")
print("INSERT INTO GROUP VALUES(" + str(oID) + ", '" + groupname + "', " + str(creator) + ");\n")
while len(PageOwnerIds) < 30:
oID = random.randint(0, 2 ** 30)
if oID not in PageOwnerIds:
PageOwnerIds.append(oID)
EventIds.append(oID)
desc = ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(150))
privacy = random.choice(privacySetting)
while True:
pageID = random.randint(0, 2 ** 30)
if pageID not in PageIds:
break
PageIds.append(pageID)
eventName = ''.join(random.choice(string.ascii_uppercase) for _ in range(45))
planner = random.choice(UserIds)
month = random.randrange(1, 12, 3)
location = random.choice(Locations)
print("INSERT INTO PageOwner VALUES(" + str(oID) + ", '" +
desc + "', '" + privacy + "', " + str(pageID) + ");")
print("INSERT INTO Event VALUES(" + str(oID) + ", '" +
eventName + "', DATE('2019-" + str(month) + "-01'), '" +
location + "', " + str(creator) + ");\n")
friends1 = itertools.combinations(UserIds,2)
friends2 = [item for item in friends1];
for (x,y) in random.sample(friends2,25):
year = random.randrange(2000, 2018)
month = random.randrange(1,12)
day = random.randrange(1,28)
print("INSERT INTO Friends VALUES(" + str(x) + ", " + str(y) + ", DATE('" +
str(year) + "-" + str(month) + "-" + str(day) + "'));")
print()
for u in UserIds:
groups = random.sample(GroupIds,3)
events = random.sample(EventIds,3)
print("INSERT INTO ADMINISTERS VALUES({},{});".format(u,groups[0]))
for i in range(3):
print("INSERT INTO MEMBEROF VALUES({},{});".format(u,groups[i]))
print("INSERT INTO GOINGTO VALUES({},{});".format(u,events[i]))
print()
while len(PostIDs) < 50:
pID = random.randint(0, 2 ** 30)
if pID not in PostIDs:
PostIDs.append(pID)
postDate = randomTimeStamp()
message = ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(100))
numHT = random.randint(0,3)
HTgs = random.sample(HashTagList,numHT)
for t in HTgs:
message = message + " " + "#" + t
poster = random.choice(UserIds)
page = random.choice(PageIds)
if random.random() < 0.5:
original = random.choice(PostIDs)
if original == pID:
original = -1
else:
original = -1
if original == -1:
print("INSERT INTO Post VALUES(" + str(pID) + ", " + postDate + ", '" +
message + "', " + str(poster) + ", " + str(page) + ", NULL);")
else:
print("INSERT INTO Post VALUES(" + str(pID) + ", " + postDate + ", '" +
message + "', " + str(poster) + ", " + str(page) + ", " + str(original) + ");")
for t in HTgs:
print("INSERT INTO ContainsTag VALUES (" + str(pID) + ", '" + t + "');")
print()
while(len(CommentIds) < 100):
cID = random.randint(0, 2 ** 30)
if cID not in CommentIds:
CommentIds.append(cID)
postDate = randomTimeStamp()
message = ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(100))
poster = random.choice(UserIds)
post = random.choice(PostIDs)
if random.random() < 0.5:
original = random.choice(CommentIds)
if original == cID:
original = -1
else:
original = -1
if original == -1:
print("INSERT INTO Comment VALUES(" + str(cID) + ", " + postDate + ", '" +
message + "', " + str(post) + ", " + str(poster) + ", NULL);")
else:
# query = "(SELECT post FROM Comment o WHERE o.cID = originalcomment)"
print("INSERT INTO Comment VALUES(" + str(cID) + ", " + postDate + ", '" +
message + "', NULL, " + str(poster) + ", " + str(original) + ");")
print()
| [
"durham.abric@mail.mcgill.ca"
] | durham.abric@mail.mcgill.ca |
fd25aa520ff58f7fe041bea54f2716475ea9c248 | 941222660c2ae971775ce1b0766859354eb69523 | /forms.py | efeeb4f0950e6a7d080bf28a6de0174c00841b5b | [] | no_license | davidcrowe/apt | ebc2ee876b67925f38571c9a74d2c8d48e8669b0 | d35c9e9edbaf3a6380ea54e3eb4ca22352c059d0 | refs/heads/master | 2022-12-02T22:45:34.351025 | 2019-08-07T02:21:19 | 2019-08-07T02:21:19 | 203,062,498 | 0 | 0 | null | 2022-11-22T04:11:55 | 2019-08-18T22:24:56 | Jupyter Notebook | UTF-8 | Python | false | false | 653 | py | from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField, SubmitField, TextAreaField
from wtforms.validators import DataRequired
class RegisterForm(FlaskForm):
username = StringField('Enter a Username:', validators=[DataRequired()])
email = StringField('Enter your Email:', validators=[DataRequired()])
password = PasswordField('Enter a Password:', validators=[DataRequired()])
submit = SubmitField('Register')
class LoginForm(FlaskForm):
username = StringField('Enter your Username:', validators=[DataRequired()])
password = PasswordField('Enter your Password:', validators=[DataRequired()])
submit = SubmitField('Login') | [
"cynthiagao2@gmail.com"
] | cynthiagao2@gmail.com |
17d6c4c1e6b1291df5026f6db7207c4b2d096f55 | 482aff6baf9b5225456a85564f2db1785536f4b4 | /lr3/19.2.py | 5fcb656a7de96c944b8d153957e566120ad49113 | [] | no_license | rohmunen/lab_rabota_34 | baaf636303f716e72f3dbf6cdc0b40c719120f8b | e5383a663d756bcd48ef4ba5df4bc8b797e91f4e | refs/heads/master | 2023-04-21T01:19:35.393275 | 2021-05-14T22:37:11 | 2021-05-14T22:37:11 | 367,493,142 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,292 | py | #БСБО-05-19 Салынь Даниил Леонидович
def letters_to_numbers(line: str):
line = line.replace("A", "1")
line = line.replace("B", "2")
line = line.replace("C", "3")
line = line.replace("D", "4")
line = line.replace("E", "5")
line = line.replace("F", "6")
line = line.replace("G", "7")
line = line.replace("H", "8")
return line
def numbers_to_letters(line: str):
line = line[:1].replace("1", "A") + line[1:]
line = line[:1].replace("2", "B") + line[1:]
line = line[:1].replace("3", "C") + line[1:]
line = line[:1].replace("4", "D") + line[1:]
line = line[:1].replace("5", "E") + line[1:]
line = line[:1].replace("6", "F") + line[1:]
line = line[:1].replace("7", "G") + line[1:]
line = line[:1].replace("8", "H") + line[1:]
return line
def coords_to_cell(x: int, y: int):
return str(x) + str(y)
def possible_turns(cell: str):
cell = letters_to_numbers(cell)
first_coordinate = int(cell[:1])
second_coordinate = int(cell[1:])
if first_coordinate + 2 < 9:
if second_coordinate + 1 < 9:
print(numbers_to_letters(coords_to_cell(first_coordinate + 2, second_coordinate + 1)))
if second_coordinate - 1 > 0:
print(numbers_to_letters(coords_to_cell(first_coordinate + 2, second_coordinate - 1)))
if first_coordinate - 2 > 0:
if second_coordinate + 1 < 9:
print(numbers_to_letters(coords_to_cell(first_coordinate - 2, second_coordinate + 1)))
if second_coordinate - 1 > 0:
print(numbers_to_letters(coords_to_cell(first_coordinate - 2, second_coordinate - 1)))
if second_coordinate + 2 < 9:
if first_coordinate + 1 < 9:
print(numbers_to_letters(coords_to_cell(first_coordinate + 1, second_coordinate + 2)))
if first_coordinate - 1 < 9:
print(numbers_to_letters(coords_to_cell(first_coordinate - 1, second_coordinate + 2)))
if second_coordinate - 2 < 9:
if first_coordinate + 1 < 9:
print(numbers_to_letters(coords_to_cell(first_coordinate + 1, second_coordinate - 2)))
if first_coordinate - 1 < 9:
print(numbers_to_letters(coords_to_cell(first_coordinate - 1, second_coordinate - 2)))
possible_turns(input())
| [
"salyndaniil@gmail.com"
] | salyndaniil@gmail.com |
4b096cd0b77a9d1d09a5c5e44b02bc2f01145812 | f6c69d41b00edabd0c85d4d600743b7ef4fd704a | /blender/select_verts_by_id.py | 657b87cb2912c926adf4ec098fcb1a0d1b80d8a2 | [
"MIT"
] | permissive | alextsui05/toolbox | f05c711b75a62eb775cc65063e2f93a8bb79df09 | 00080c8ef7a9a5f2f9b194f1d0fe4b2c41a6b95a | refs/heads/master | 2021-01-15T14:28:35.609732 | 2015-03-08T02:24:45 | 2015-03-08T02:24:45 | 31,831,146 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 482 | py | # Usage:
# Paste this into the Python console in blender.
# Load a mesh and deselect it in Edit mode.
# Go back to Object mode and make sure the mesh is selected.
# Call foo with a list of vertex IDs you want selected, e.g.
# foo([1, 5, 7])
# Tab into Edit mode and see the vertices highlighted.
def foo(ids):
for vert in bpy.context.active_object.data.vertices:
vert.select = False
for id in ids:
bpy.context.active_object.data.vertices[id].select = True
| [
"atsui@ucdavis.edu"
] | atsui@ucdavis.edu |
48debefe3c9f7ce321e5cf391bfb715fad8579b7 | c017cc52b62f40547bad3f6414729c32d7cbd494 | /picklefield/compat.py | 275501ec30b43070930519a40c650cb2105e318f | [
"MIT"
] | permissive | xflows/clowdflows-backend | 6ef7f2cc0b7eac6b5b04e48c80355a8df71be69a | 9d38895abee65f36699f6dc199584d431826845c | refs/heads/master | 2023-04-04T05:25:24.684332 | 2022-11-16T15:15:09 | 2022-11-16T15:15:09 | 87,054,178 | 5 | 0 | MIT | 2023-03-31T14:34:15 | 2017-04-03T08:38:55 | Python | UTF-8 | Python | false | false | 268 | py | import django
from django.db import models
from django.utils import six
from pickle import loads, dumps # noqa
if django.VERSION >= (1, 8):
_PickledObjectField = models.Field
else:
_PickledObjectField = six.with_metaclass(models.SubfieldBase, models.Field)
| [
"anze.vavpetic@ijs.si"
] | anze.vavpetic@ijs.si |
202cdde1f06f0ea912beff46cc04a4d60b559e64 | 249c9f6bf3b6ff08ad9793901ea415382b352f06 | /submit_data.py | 3c92685b0709b744f9557f98fc0a48579afef726 | [] | no_license | bipinaghimire/ExamReplacement_programming | 3c0a3434202f7c9d12f0287e022377ddd645502b | d30e4f2dd3e8c6c4a3df349c447dbf4cc2bfa3c0 | refs/heads/main | 2023-08-10T19:47:13.519439 | 2021-10-02T09:06:17 | 2021-10-02T09:06:17 | 412,481,445 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 7,965 | py | import sqlite3
from tkinter import *
from PIL import ImageTk, Image
from tkinter import ttk
manage = Tk()
manage.title('Registration')
manage.geometry('1500x900')
manage.configure(bg='Light Blue')
manage.iconbitmap('icon.ico')
# connect to database
conn = sqlite3.connect('School_Management.db')
# create a cursor
c = conn.cursor()
"""
c.execute(('''CREATE TABLE addresses(
student_id integer,
first_name text ,
middle_name text,
last_name text ,
class text,
age integer ,
gender text ,
date_of_birth integer,
address text ,
mother_name text ,
father_name text,
email_address text,
contact_number integer,
date_of_admission integer
)'''))
print("Table created")
"""
# Making title and frames
Title_frame = Frame(manage, bd=10, bg='black', width=1500, relief=RIDGE)
Title_frame.place(x=250, y=15)
Title_frame_label = Label(Title_frame, font=('Cambria 15 italic', 25, 'bold'), bg='light pink',
text='SOFTWARICA COLLEGE OF IT AND E-COMMERCE', padx=20)
Title_frame_label.grid()
Entry_frame_details = Frame(manage, bd=10, bg='black', width=1250, height=500, padx=250, relief=RIDGE)
Entry_frame_details.place(x=50, y=100)
# Using an image as background
image = Image.open('school.PNG')
image = image.resize((1225, 475), Image.ANTIALIAS)
pic = ImageTk.PhotoImage(image)
img = Label(Entry_frame_details, image=pic).place(x=-252, y=0)
# Create text boxes
id = Entry(Entry_frame_details, font='Cambria 15 italic', width=22, borderwidth=5)
id.place(x=720, y=15)
first_name = Entry(Entry_frame_details, font='Cambria 15 italic', width=22, borderwidth=5)
first_name.place(x=-120, y=65)
Middle_name = Entry(Entry_frame_details, font='Cambria 15 italic', width=22, borderwidth=5)
Middle_name.place(x=320, y=65)
last_name = Entry(Entry_frame_details, font='Cambria 15 italic', width=22, borderwidth=5)
last_name.place(x=720, y=65)
Class = Entry(Entry_frame_details, font='Cambria 15 italic', width=13, borderwidth=5)
Class.place(x=-120, y=115)
age = Entry(Entry_frame_details, font='Cambria 15 italic', width=9, borderwidth=5)
age.place(x=150, y=115)
address = Entry(Entry_frame_details, font='Cambria 15 italic', width=36, borderwidth=5)
address.place(x=-120, y=170)
date_of_birth = Entry(Entry_frame_details, font='Cambria 15 italic', width=22, borderwidth=5)
date_of_birth.place(x=720, y=113)
gender = ttk.Combobox(Entry_frame_details, font='Cambria 15 italic', state="readonly", width=7)
gender['values'] = ("Male", "Female")
gender.place(x=390, y=115)
father_name = Entry(Entry_frame_details, font='Cambria 15 italic', width=22, borderwidth=5)
father_name.place(x=325, y=220)
mother_name = Entry(Entry_frame_details, font='Cambria 15 italic', width=22, borderwidth=5)
mother_name.place(x=-100, y=220)
Contact_number = Entry(Entry_frame_details, font='Cambria 15 italic', width=18, borderwidth=5)
Contact_number.place(x=763, y=220)
Email_address = Entry(Entry_frame_details, font=('Cambria 15 italic', 14,), width=40, borderwidth=5)
Email_address.place(x=522, y=170)
Date_of_admission = Entry(Entry_frame_details, font='Cambria 15 italic', width=22, borderwidth=5)
Date_of_admission.place(x=-80, y=270)
# create textLabels
label = Label(Entry_frame_details, text='ENTER STUDENT DETAILS', font=('Cambria 15 italic', 17, 'bold'),
bg='Grey').place(x=-248, y=15)
id_label = Label(Entry_frame_details, font='Cambria 15 italic', text='Student ID', bg='black', fg='white',
relief=SUNKEN, bd=5).place(x=600, y=15)
first_name_label = Label(Entry_frame_details, text='First Name', font='Cambria 15 italic', bg='black', fg='white',
relief=SUNKEN, bd=5).place(x=-248, y=65)
Middle_name_label = Label(Entry_frame_details, text='Middle Name', font='Cambria 15 italic', bg='black', fg='white',
relief=SUNKEN, bd=5).place(x=190, y=65)
last_name_label = Label(Entry_frame_details, font='Cambria 15 italic', text='Last Name', bg='black', fg='white',
relief=SUNKEN, bd=5).place(x=600, y=65)
class_label = Label(Entry_frame_details, text='Class', font='Cambria 15 italic', bg='black', fg='white', relief=SUNKEN,
bd=5).place(x=-248, y=115)
age_label = Label(Entry_frame_details, font='Cambria 15 italic', text='Age', bg='black', fg='white', relief=SUNKEN,
bd=5).place(x=90, y=115)
address_label = Label(Entry_frame_details, font='Cambria 15 italic', text='Address', bg='black', fg='white',
relief=SUNKEN, bd=5).place(x=-248, y=170)
date_of_birth_label = Label(Entry_frame_details, font='Cambria 15 italic', text='Date Of Birth(*in AD)', bg='black',
fg='white', relief=SUNKEN, bd=5).place(x=520, y=113)
gender_label = Label(Entry_frame_details, font='Cambria 15 italic', text='Gender', bg='black', fg='white',
relief=SUNKEN, bd=5).place(x=290, y=115)
father_name_label = Label(Entry_frame_details, font='Cambria 15 italic', text="Father's Name ", bg='black', fg='white',
relief=SUNKEN, bd=5).place(x=177, y=220)
mother_name_label = Label(Entry_frame_details, font='Cambria 15 italic', text="Mother's Name ", bg='black', fg='white',
relief=SUNKEN, bd=5).place(x=-248, y=220)
Contact_number_label = Label(Entry_frame_details, font='Cambria 15 italic', text='Contact Number', bg='black',
fg='white', relief=SUNKEN, bd=5).place(x=600, y=220)
Email_label = Label(Entry_frame_details, font='Cambria 15 italic', text='Email address', bg='black', fg='white',
relief=SUNKEN, bd=5).place(x=365, y=170)
Date_of_admission_label = Label(Entry_frame_details, font='Cambria 15 italic', text='Date Of Admission', bg='black',
fg='white', bd=5, relief=SUNKEN).place(x=-248, y=275)
def submit():
""" This is the function that helps us to submit the entered data."""
conn = sqlite3.connect('School_Management.db')
c = conn.cursor()
# insert into table
c.execute(
"INSERT INTO addresses VAlUES(:student_id,:first_name, :middle_name,:last_name,:class,:age,:gender,:date_of_birth,:address,:mother_name,:father_name,:email_address,:contact_number,:date_of_admission)",
{
'student_id': id.get(),
'first_name': first_name.get(),
'middle_name': Middle_name.get(),
'last_name': last_name.get(),
'class': Class.get(),
'age': age.get(),
'gender': gender.get(),
'date_of_birth': date_of_birth.get(),
'address': address.get(),
'mother_name': mother_name.get(),
'father_name': father_name.get(),
'email_address': Email_address.get(),
'contact_number': Contact_number.get(),
'date_of_admission': Date_of_admission.get()
})
print('Address inserted successfully')
conn.commit()
conn.close()
# Making the entries clean to enter new entries
id.delete(0, END)
first_name.delete(0, END)
Middle_name.delete(0, END)
last_name.delete(0, END)
Class.delete(0, END)
age.delete(0, END)
gender.delete(0, END)
date_of_birth.delete(0, END)
address.delete(0, END)
mother_name.delete(0, END)
father_name.delete(0, END)
Email_address.delete(0, END)
Contact_number.delete(0, END)
Date_of_admission.delete(0, END)
# Printing the doc string
print(submit.__doc__)
#Creating buttons
submit_button = Button(Entry_frame_details, text='SUBMIT', font=('Cambria 15 italic', 13, 'bold'), width=10, bd=5,command= submit)
submit_button.place(x=170, y=350)
show_button = Button(Entry_frame_details, text='SHOW RECORDS', font=('Cambria 15 italic', 13, 'bold'), width=15, bd=5)
show_button.place(x=450, y=350)
conn.commit()
conn.close()
mainloop() | [
"bipinaghimire6@gmail.com"
] | bipinaghimire6@gmail.com |
b26f9bc07c929b3c0e64e12ec0b4ba3b39b28270 | d489b26874bbfb0848e3146602203d3f680d4544 | /postgresql_repository.py | c7c50d516e212cc0e23023d10cba61fcc4efd6c0 | [] | no_license | scrum-board-352/database-cronjob | 8caae5495a4c7b1cf6c3c2397c7c3d7235ad2213 | 968ec1c7bf51564825cf518886b67fc792dc5f6c | refs/heads/master | 2022-12-26T19:24:13.586484 | 2020-10-11T15:23:08 | 2020-10-11T15:23:08 | 298,490,148 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 856 | py | import psycopg2
def connect_postgresql(database, user="postgres", password="postgres", host="localhost", port="5432"):
conn = psycopg2.connect(database=database, user=user, password=password, host=host, port=port)
cur = conn.cursor()
return cur
def search_table_and_create_subtype_dict(cur, select_statement):
cur.execute(select_statement)
subtype_dict1 = dict()
subtype_dict2 = dict()
select_rows = cur.fetchall()
for row in select_rows:
if subtype_dict1.get(row[1]) is None:
subtype_dict1[row[1]] = [row[0]]
else:
subtype_dict1[row[1]].append(row[0])
for row in select_rows:
if subtype_dict2.get(row[0]) is None:
subtype_dict2[row[0]] = [row[1]]
else:
subtype_dict2[row[0]].append(row[1])
return subtype_dict1, subtype_dict2
| [
"913057041@qq.com"
] | 913057041@qq.com |
e9842c0f6d8deaab2233e71ede7d7886c0f2bed2 | f5932c296324728b6043b674a1ac8186f24e5cf1 | /cart/views.py | e74a287471af97a08c642628964dd1066a99fa27 | [] | no_license | Geerocktricks/stylist-vem | c6e0aa552e06488b313d0e80380e2aa98d8b4c6b | a42c3ac8680e89591eb91f16fbcd24c1274cfadd | refs/heads/main | 2023-01-07T15:55:48.782924 | 2020-11-10T18:55:03 | 2020-11-10T18:55:03 | 311,770,740 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,006 | py | from django.shortcuts import render, redirect, get_object_or_404
from django.views.decorators.http import require_POST
from stylistapp.models import Product
from .cart import Cart
from .forms import CartAddProductForm
@require_POST
def cart_add(request, product_id):
cart = Cart(request)
product = get_object_or_404(Product, id=product_id)
form = CartAddProductForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
cart.add(product=product, quantity=cd['quantity'], update_quantity=cd['update'])
return redirect('cart_detail')
def cart_remove(request, product_id):
cart = Cart(request)
product = get_object_or_404(Product, id=product_id)
cart.remove(product)
return redirect('cart_detail')
def cart_detail(request):
cart = Cart(request)
for item in cart:
item['update_quantity_form'] = CartAddProductForm(initial={'quantity': item['quantity'], 'update': True})
return render(request, 'cart/detail.html', {'cart': cart})
| [
"geerockface4@gmail.com"
] | geerockface4@gmail.com |
f43b801df2a2396b5627c17b19e71a5d8c8eeef8 | 53fab060fa262e5d5026e0807d93c75fb81e67b9 | /backup/user_258/ch30_2019_03_10_21_05_56_563616.py | c59f95da9501a2311605f0176a60d8e35f2f4a9f | [] | no_license | gabriellaec/desoft-analise-exercicios | b77c6999424c5ce7e44086a12589a0ad43d6adca | 01940ab0897aa6005764fc220b900e4d6161d36b | refs/heads/main | 2023-01-31T17:19:42.050628 | 2020-12-16T05:21:31 | 2020-12-16T05:21:31 | 306,735,108 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 255 | py | import math
v=int(input('Qual a velocidade do lançamento? '))
a=int(input('Qual o ângulo do lançamento? '))
d=(v**2)*math.sin(2*math.degrees(a))/9.8
if d<96:
print('Muito perto')
elif d>104:
print('Muito longe')
else:
print('Acertou!')
| [
"you@example.com"
] | you@example.com |
82de4cfcd9dd16a9de9e20740c96e2672531521a | 4cbc8b81d197bc392d1b57856254300331b9738f | /python/apt.py | e87a96e500abda1744a02b482a2c973b8f718a19 | [
"MIT"
] | permissive | vcatafesta/chili | 87b9606f17cda645ba44cbf2bb4cc4637e18d211 | 5c734ac88454db76eb2f4e92c13364a5bbc7a93a | refs/heads/main | 2023-09-01T01:39:09.457448 | 2023-08-29T21:23:28 | 2023-08-29T21:23:28 | 171,972,556 | 2 | 2 | null | 2019-02-22T01:38:49 | 2019-02-22T01:26:46 | null | UTF-8 | Python | false | false | 15,595 | py | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
# License: MIT #
#url = 'http://mazonos.com/packages/' # Official Repository
url = 'http://localhost/packages/' # Official Repository
#url = 'https://github.com/vcatafesta/ChiliOS/tree/master/' # Official Repository
#filecsv = '/var/lib/fetch/database.db' # Repository package list
filecsv = 'database.db' # Repository package list
dircsv = '/var/lib/fetch/' # Folder for the .csv file
dirlist = '/var/lib/banana/list/' # Folder for the .list file
PRG = '.chi.zst'
#PRG = '.mz'
# Flags
found = False
done = False
fi = ""
rof = ""
end = ""
endef = ""
next = ""
#define
PKG_FULLNAME = 0
PKG_ARCH = 1
PKG_BASE = 2
PKG_BASE_VERSION = 3
PKG_VERSION = 4
PKG_BUILD = 5
#Strings
choose = ''
textAnimate = ''
please_connect = 'No route to server! Check your internet connection!'
package_not_found = 'Package not found.'
# Arrays
switches = [
's', 'search',
'i', 'install',
'r', 'remove',
'w', 'show',
'u', 'update',
'g', 'upgrade',
'c', 'checkdesc'
]
modules = ['requests', 'requests_html', 'bs4', 'argparse', 'consolecolor', 'sty']
import sys
import os
import csv
import threading
import itertools
import time
import re
for module in modules:
try:
__import__(module)
except Exception as e:
print('Installing modules...')
os.system('pip3 install ' + str(module))
# os.system('clear')
end
import requests
import requests_html
import bs4
from urllib.request import urlopen
from bs4 import BeautifulSoup
from requests_html import HTMLSession
from consolecolor import FontColor
from consolecolor import Colors
from sty import fg, bg, ef, rs, RgbFg
fg.set_style('orange', RgbFg(255, 150, 50))
def version():
print(''' __ _ _
/ _| ___| |_ ___| |__ Copyright (C) 2019-2020 Vilmar Catafesta <vcatafesta@gmail.com>
| |_ / _ \ __/ __| '_ \
| _| __/ || (__| | | | Este programa pode ser redistribuído livremente
|_| \___|\__\___|_| |_| sob os termos da Licença Pública Geral GNU.
fetch 1.00.00.20200817
''')
def check():
#Checks if the folder exists
if not os.path.isdir(dircsv):
os.mkdir(dircsv)
print('Created folder ' + dircsv + '.')
fi
# Checks if the file exists
if not os.path.isfile(filecsv):
os.system('touch ' + filecsv)
print('Created file ' + filecsv + '.')
os.system('clear')
update()
fi
def main():
try:
sys.argv[1]
except IndexError:
usage()
exit(1)
else:
global choose
choose = str(sys.argv[1])
def usage():
print('erro: nenhuma operação especificada (use -h para obter ajuda)')
def usage():
print('''uso: fetch <operação> [...]
operações:
fetch {-h --help}
fetch {-V --version}
fetch {-D --database} <opções> <pacote(s)>
fetch {-F --files} [opções] [pacote(s)]
fetch {-Q --query} [opções] [pacote(s)]
fetch {-R --remove} [opções] <pacote(s)>
fetch {-S --sync} [opções] [pacote(s)]
fetch {-T --deptest} [opções] [pacote(s)]
fetch {-U --upgrade} [opções] <arquivo(s)>
use "fetch {-h --help}" com uma operação para ver as opções disponíveis
''')
def internet_on():
try:
response = urlopen(url, timeout=10)
return True
except:
return False
def animate():
for c in itertools.cycle(['|', '/', '-', '\\']):
if done:
break
fi
sys.stdout.write('\r' + textAnimate + c)
sys.stdout.flush()
time.sleep(0.1)
next
sys.stdout.write('\r' + textAnimate + 'complete! \n')
def s():
search()
def search():
global found
if (len(sys.argv) >= 3):
package = str(sys.argv[2])
else:
package = None
fi
with open(filecsv, 'r') as f:
csv_reader = csv.reader(f)
count = 0
linepackage()
for line in csv_reader:
if package:
if package in line[0]:
count += 1
print("{}({:04d}) {}{:<30}{} {:<20} {:<40}".format(fg.green, count, fg.orange, line[0].replace(PRG, ''), fg.rs, line[1], line[4]))
found = True
fi
else:
count += 1
print("{}({:04d}) {}{:<30}{} {:<20} {:<40}".format(fg.green, count, fg.orange, line[0].replace(PRG, ''), fg.rs, line[1], line[4]))
found = True
fi
next
print('(' + str(count) + ') package(s) found.')
if not found:
print(package_not_found)
fi
end
def linepackage():
print(fg.cyan + ' Package version fullname' + fg.rs)
return
def i():
install()
def install():
if internet_on():
try:
sys.argv[2]
except IndexError:
usage()
exit(0)
else:
global found
package = str(sys.argv[2])
links = []
packages = []
with open(filecsv, 'r') as f:
csv_reader = csv.reader(f)
count = 0
linepackage()
for line in csv_reader:
if package in line[0]:
found = True
count += 1
print("{}({:04d}) {}{:<30}{} {:<20} {:<40}".format(fg.green, count, fg.orange, line[0].replace(PRG, ''), fg.rs, line[1], line[4]))
links.append(url + line[4])
packages.append(line[3])
fi
next
if found:
pkgcount = packages.__len__()
pkglist = ''
for p in packages:
pkglist += (p + ', ')
next
pkglist = pkglist[:-2] + '.'
# print(str(pkgcount) + ' packages found: ' + pkglist.replace(PRG, ''))
print()
install = input(':: Continue installation? [Y/n] : ')
if install == 'Y' or install == 'y':
for p in range(pkgcount):
cstr = 'curl'
cstr += ' -#'
cstr += ' -k'
cstr += ' -o /tmp/' + packages[p]
cstr += ' -O ' + links[p]
os.system(cstr)
os.system('(banana -i ' + '/tmp/' + packages[p] + '2>&1>/dev/null)')
# os.system('rm ' + '/tmp/' + packages[p])
rof
else:
exit(0)
fi
else: # if not found
print(package_not_found)
fi
end
end
else:
print(please_connect)
exit(0)
fi
def r():
remove()
def remove():
try:
sys.argv[2]
except IndexError:
usage()
exit(0)
else:
global found
onlyfiles = [f for f in os.listdir(dirlist) if os.path.isfile(os.path.join(dirlist, f))]
r = re.compile(sys.argv[2] + '.*')
newlist = list(filter(r.match, onlyfiles))
if newlist:
found = True
for pack in newlist:
package = pack.replace('.list', '')
remove = input('You like remove ' + package + '? [Y/n] : ')
if remove == 'y' or remove == 'Y':
os.system('banana remove ' + package + ' -y')
else:
exit(0)
if not found:
print(package_not_found)
def w():
show()
def show():
try:
sys.argv[2]
except IndexError:
usage()
exit(0)
else:
global found
package = str(sys.argv[2])
with open(filecsv, 'r') as f:
csv_reader = csv.reader(f)
for line in csv_reader:
if package in line[0]:
found = True
pkgname = line[0]
version = line[1]
internet = internet_on()
lDesc = False
if line[4]:
if internet:
r = requests.get(url + line[4] + '.desc' )
if not r.status_code == 404:
lDesc = True
text = r.text
fi
fi
fi
if not lDesc:
maintainer = '(unknown)'
desc = 'Description not available for this package!'
if not internet:
desc += '\n' + please_connect
fi
else:
maintainer = (re.findall('maintainer.*', text)[0]).replace("'", '').replace('maintainer=', '').replace('"', '')
desc = (re.findall('desc.*', text)[0]).replace("'", '').replace('desc=', '').replace('"', '')
#desc = ((text.split('|')[2]).replace('#', '').replace('=', '').replace('desc"', ''))[:-2]
fi
print( fg.cyan + text + fg.rs )
# print('Package Name: ' + pkgname)
# print('Version.....: ' + version)
# print('Maintainer..: ' + maintainer)
# print('Desc........: ' + desc)
# print('#' * 70)
fi
next
if not found:
print(package_not_found)
fi
end
end
def u():
update()
def pause( xVar ):
os.system('clear')
print( xVar )
resp = 'S'
resp = input('Continuar [Y/n] : ')
if resp == 'Y' or resp == 'y' or resp == 'S' or resp == 's':
return
fi
exit(1)
def update():
if internet_on():
global textAnimate
global done
if os.path.isfile(filecsv):
os.system('rm ' + filecsv)
fi
result = requests.get(url)
src = result.content
soup = BeautifulSoup(src, 'html.parser')
links = soup.find_all('a')
ntotalpkg = 0
for link in links:
if '../' in link.text:
continue
fi
if '/' in link.text:
urls = url + link.get('href')
result = requests.get(urls)
src = result.content
soup = BeautifulSoup(src, 'html.parser')
folders = soup.find_all('a')
folder = link.text
ncontapkg = 0
for l in folders:
pkg = l.get('href')
string = ''
if l.text.endswith((PRG)):
ncontapkg += 1
ntotalpkg += 1
string = pkg
pkgsplit = splitpkg(pkg)
with open(filecsv, 'a') as f:
csv_writer = csv.writer(f)
csv_writer.writerow([pkgsplit[PKG_BASE], pkgsplit[PKG_VERSION], pkgsplit[PKG_BUILD], string, folder+string])
end
fi
rof
print("{}::{}Updating... {}({:04d}) {}packages in {}{}{}".format(fg.cyan, fg.rs, fg.cyan, ncontapkg, fg.red, fg.yellow, link.get('href'),fg.rs))
fi
rof
print('')
print("{}({:04d}) {}packages{} in repo".format(fg.cyan, ntotalpkg, fg.red, fg.rs))
done = True
else:
print(please_connect)
fi
def splitpkg(cfilename):
cfullname = cfilename
pkg_arch = cfullname.replace('-any' + PRG,'')
pkg_arch = pkg_arch.replace('-x86_64' + PRG,'')
# pkg_arch = pkg_arch.replace(PRG,'')
carch = cfullname.replace(PRG,'')
csplit = pkg_arch.rsplit('-',2)
cbase = csplit[0]
cbase_version = cfilename.rsplit('-',1)[0]
cbuild = csplit[2]
cversion = csplit[1]
cversion += '-'
cversion += cbuild
return( cfullname, carch, cbase, cbase_version, cversion, cbuild)
def g():
upgrade()
def upgrade():
print('Upgrading...')
def c():
checkdesc()
def checkdesc():
if internet_on():
update()
global textAnimate
global done
found = False
nodescs = []
textAnimate = 'Searching '
t = threading.Thread(target=animate)
t.start()
with open(filecsv, 'r') as f:
csv_reader = csv.reader(f)
for line in csv_reader:
if line[2] == '':
found = True
nodescs.append(' ' + line[0] + line[1] + '.desc -> not found!')
fi
end
done = True
end
if found:
print('The following packages do not have the .desc file:')
for n in nodescs:
print(n)
else:
print('All packages are OK!')
fi
else:
print(please_connect)
exit(1)
fi
switches = [
's', 'search',
'i', 'install',
'r', 'remove',
'w', 'show',
'u', 'update',
'g', 'upgrade',
'c', 'checkdesc'
]
def indirect(i):
switcher={
'-h':usage, '--help':usage,
'-Sy':update,
'-Sw':show,
'-Si':install,
'-Su':upgrade,
'-R':remove,
'-Q':search,
'-V':version,
'-f':lambda: 'force',
'-y':lambda: 'auto'
}
func=switcher.get(i, lambda: 'invalid')
return func()
try:
check()
main()
# if choose in switches:
# functions = locals()
# functions[choose]()
# else:
# usage()
# print('Invalid \"' + choose + '\" operation!')
indirect(sys.argv[1])
except KeyboardInterrupt:
print('\n')
exit(0)
import sys
import argparse
#def main():
# parser = argparse.ArgumentParser(description='ChiliOS fetch') # (1)
# parser.add_argument('-Sy', nargs='*', type=str, default='', required=False, help='Sync') #(2)
# parser.add_argument('-Su', nargs='*', type=str, default='', required=False, help='Sync') #(2)
# parser.add_argument('-f', dest='force', nargs='*', type=str, default='', required=False, help='Sync') #(2)
# parser.add_argument('-y', dest='auto', nargs='*', type=str, default='', required=False, help='Sync') #(2)
# args = parser.parse_args() #(3)
# choose = 'Sy'
# if choose in switches:
# functions = locals()
# pause( functions )
# functions['update']()
# print("Sy={}".format(args.Sy)) # (4)
# print("Su={}".format(args.Su)) # (4)
# print(" f={}".format(args.force)) # (4)
# print(" y={}".format(args.auto)) # (4)
# return 0
if __name__ == '__main__':
sys.exit(main())
| [
"vcatafesta@gmail.com"
] | vcatafesta@gmail.com |
a27255775c359e6349422a11cc3ac11223310a05 | 8b4f907bac3298adff1071ab61ac0e53666a60e2 | /classify.py | 07a1aaa68ffa0c2e5115613d3cca5e6c43718ec1 | [] | no_license | ZhuoruLin/Generative_Adversarial_Nets | 9bc1a083a3b4477586e07b54bb1cd8ceff72feed | 770db8aead724aa0d0c035d1ea94141c78ff2d88 | refs/heads/master | 2021-01-20T00:34:30.426145 | 2017-05-05T22:03:33 | 2017-05-05T22:03:33 | 89,153,157 | 0 | 1 | null | null | null | null | UTF-8 | Python | false | false | 1,326 | py | import numpy as np
import itertools
import os
file = []
for line in open('./list_attr_celeba.txt','r').read().splitlines():
file.append(list(filter(None, line.split(' '))))
file.remove(file[0])
file = np.array(file)
columns = file[0]
legit = False
while not legit:
attrs = np.unique(input('Input attrs to classify, split by space').split(' '))
legit = True
for attr in attrs:
if attr not in file[0]:
print(attr + 'is not an attribute')
legit = False
values = []
for attr in attrs:
element = []
for j in [1, -1]:
element.append(attr + '=' + str(j))
values.append(element)
names = list(itertools.product(*values))
for name in names:
directory = ''
for i in range(len(name)):
directory += (name[i])
if i < len(name) - 1:
directory += ' & '
if not os.path.exists(directory):
os.makedirs(directory)
for i in range(1, len(file)):
classified_directory = './'
for j in range(len(attrs)):
attr = attrs[j]
classified_directory += (attr + '=' + str(file[i][columns.index(attr) + 1]))
if j < len(attrs) - 1:
classified_directory += ' & '
old_path = './img_align_celeba/' + file[i][0]
new_path = classified_directory + '/' + file[i][0]
os.rename(old_path, new_path) | [
"wz1070@nyu.edu"
] | wz1070@nyu.edu |
1f66c2f28360a924a6ad07d2b8c8af414203518d | 50f8d8975b1f17c4c6bcb9be29d4f0ed49cb42a5 | /Week_04/lemonade-change.py | 5e567df5df1217ba3921dd4a56cf9268dd95ae3f | [] | no_license | Jiangjao/-algorithm015 | 098491b7a9b80626c1d9e15a9125e4e460ee8668 | a6969617f4cde1d948cb064c1078d4d510140758 | refs/heads/master | 2023-01-10T17:42:49.495871 | 2020-11-16T07:35:04 | 2020-11-16T07:35:04 | 289,441,446 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 608 | py | class Solution(object):
def lemonadeChange(self, bills):
"""
:type bills: List[int]
:rtype: bool
"""
five = ten = 0
for bill in bills:
if bill == 5:
five += 1
elif bill == 10:
if not five: return False
five -= 1
ten += 1
else:
if ten and five:
ten -= 1
five -= 1
elif five >= 3:
five -= 3
else:
return False
return True | [
"918718278@qq.com"
] | 918718278@qq.com |
12855ffac428a1b4748a02676b891fc3376ba488 | d07990b3bcae8ba6f03b73503db4a0dbfe86b0a8 | /26/26.py | e280f36404c8b631f669894de239aa510003fc79 | [] | no_license | domino14/euler | 97aa6a9c7eaa154e77eaf6d517867c4e4def5b97 | 76034df727412cd37956d204e99d486bee7cf21e | refs/heads/master | 2021-01-17T11:15:36.478967 | 2018-05-22T06:32:51 | 2018-05-22T06:32:51 | 15,523,557 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,984 | py | def divide_to_accuracy(x, y, digits):
"""
x / y to digits accuracy.
:x an integer
:y an integer
:digits the number of digits after the decimal point
Return a string representing the accuracy.
"""
accumulator = ''
# Implement grade school division algorithm?
quotient, remainder = divmod(x, y)
accumulator += str(quotient) + '.'
for d in range(digits):
x = remainder * 10
quotient, remainder = divmod(x, y)
accumulator += str(quotient)
return accumulator
# '082082'
def string_repeats(s):
""" This returns the repeating string within s, but it assumes s
only consists of repeating strings (so we must remove prefix) """
double = s + s
idx = double.find(s, 1, -1)
if idx == -1:
return None
return double[:idx]
def recurring_cycle_length(x, y):
""" Find the length of the recurring cycle when dividing x / y """
accumulator = ''
# Implement grade school division algorithm?
quotient, remainder = divmod(x, y)
accumulator += str(quotient) + '.'
after_dec = ''
max_rep_length = 0
max_prefix_length = 10 #
num_times_1 = 0
for d in range(2000):
x = remainder * 10
quotient, remainder = divmod(x, y)
after_dec += str(quotient)
for i in range(max_prefix_length):
rep = string_repeats(after_dec[i:])
if rep:
if len(rep) > max_rep_length:
max_rep_length = len(rep)
if len(rep) == 1:
num_times_1 += 1
if num_times_1 > 10:
break
return max_rep_length
# 0.0|102040816326530612244897959183673469387755|102040
cycle_length = 0
d = 0
for i in range(1, 1000):
l = recurring_cycle_length(1, i)
if l > cycle_length:
cycle_length = l
d = i
print i, recurring_cycle_length(1, i)
# God I hate this hacky solution.
print "Longest length is", cycle_length, "for d =", d
| [
"delsolar@gmail.com"
] | delsolar@gmail.com |
5f249cf5e48d2382470baa0a978bc3a0abafafc6 | d2ca1ab6ed63983d1bd6497f26a63f0445451844 | /2015/05/fc_2015_05_31.py | dc41dc9178467c3c8859ffc19ce4fdb301b45b7d | [
"MIT"
] | permissive | mfwarren/FreeCoding | 96636367f4f4a53351535372c5691d7805199f23 | 58ac87f35ad2004a3514782556762ee0ed72c39a | refs/heads/master | 2021-01-19T14:30:09.057354 | 2015-07-05T05:59:53 | 2015-07-05T05:59:53 | 24,469,988 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 444 | py | #!/usr/bin/env python3
# imports go here
#
# Free Coding session for 2015-05-31
# Written by Matt Warren
#
def factors(x):
values = []
cursor = x
i = 2
while i <= cursor:
v = cursor / i
if int(v) == v:
cursor = v
values.append(i)
else:
i += 1
return values
if __name__ == '__main__':
print(factors(302))
print(factors(304))
print(factors(30473456))
| [
"matt.warren@gmail.com"
] | matt.warren@gmail.com |
86a4b424729bcfcbf3c2eda194a7fcf64ca2224b | 8a430156a31c84a1760150d8ec9bebe55c264a12 | /SecureVault/settings.py | f92d9cdf25a61a7a5b2e20e5a3c4042f0f449c1b | [] | no_license | SQasimHamdani/AI-Smart-SecureVault | 4a83551d9d842bf7ed557b5879af6b64a8c49983 | 952311734989fa4833c0b70c5cb5ea71c6c30eee | refs/heads/main | 2023-04-29T20:46:18.972102 | 2021-05-19T22:29:36 | 2021-05-19T22:29:36 | 367,734,035 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 3,560 | py | """
Django settings for SecureVault project.
Generated by 'django-admin startproject' using Django 3.0.6.
For more information on this file, see
https://docs.djangoproject.com/en/3.0/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/3.0/ref/settings/
"""
import os
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.0/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = '-ub4lx4@%3-*!9j*6$!765&s@7=7k6$q2ks&z$dpn4f5wa9$af'
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True
ALLOWED_HOSTS = []
# Application definition
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'Accounts',
]
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
ROOT_URLCONF = 'SecureVault.urls'
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [os.path.join(BASE_DIR, 'templates')],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]
WSGI_APPLICATION = 'SecureVault.wsgi.application'
# Database
# https://docs.djangoproject.com/en/3.0/ref/settings/#databases
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
}
}
# Password validation
# https://docs.djangoproject.com/en/3.0/ref/settings/#auth-password-validators
AUTH_PASSWORD_VALIDATORS = [
{
'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
},
]
# Internationalization
# https://docs.djangoproject.com/en/3.0/topics/i18n/
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'
USE_I18N = True
USE_L10N = True
USE_TZ = True
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/3.0/howto/static-files/
STATIC_URL = '/static/'
# STATIC_ROOT = os.path.join(BASE_DIR,STATIC_URL.replace("/",""))
STATIC_ROOT = os.path.join(BASE_DIR,"static-cdn")
# STATIC_ROOT = r"E:\AA - Working Projects\a New\FYP_Hamza_Haseeb\Django Project\SecureVault\static"
# print(STATIC_ROOT)
STATICFILES_DIRS = [
os.path.join(BASE_DIR, "static"),
]
MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, MEDIA_URL.replace("/",""))
# print(MEDIA_ROOT) | [
"near2qasim@gmail.com"
] | near2qasim@gmail.com |
b641ec2e312530de25f9cc7ecd3cde2d9955606e | 7574feacccf1873a92291d9864118ff15fa52fe4 | /src/trainConvNet.py | 7fa0f68e3b9f9dedf7e72707be4ce118f075c0a4 | [
"MIT"
] | permissive | jbmorlot/HiCPlus | 626e98444d6a2a8ae08312e6804cb8023cf51e6d | 2313aaed844ccfb17a460d755d512828b42e9ecf | refs/heads/master | 2020-03-19T00:16:29.902596 | 2018-05-30T16:30:22 | 2018-05-30T16:30:22 | 135,468,576 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 4,309 | py | # Author: Yan Zhang
# Email: zhangyan.cse (@) gmail.com
import sys
import numpy as np
import matplotlib.pyplot as plt
import pickle
import os
import gzip
import model
from torch.utils import data
import torch
import torch.optim as optim
from torch.autograd import Variable
from time import gmtime, strftime
import sys
import torch.nn as nn
use_gpu = 1
conv2d1_filters_numbers = 8
conv2d1_filters_size = 9
conv2d2_filters_numbers = 8
conv2d2_filters_size = 1
conv2d3_filters_numbers = 1
conv2d3_filters_size = 5
down_sample_ratio = 16
epochs = 10
HiC_max_value = 100
batch_size = 256
# This block is the actual training data used in the training. The training data is too large to put on Github, so only toy data is used.
# cell = "GM12878_replicate"
# chrN_range1 = '1_8'
# chrN_range = '1_8'
# low_resolution_samples = np.load(gzip.GzipFile('/home/zhangyan/SRHiC_samples/'+cell+'down16_chr'+chrN_range+'.npy.gz', "r")).astype(np.float32) * down_sample_ratio
# high_resolution_samples = np.load(gzip.GzipFile('/home/zhangyan/SRHiC_samples/original10k/'+cell+'_original_chr'+chrN_range+'.npy.gz', "r")).astype(np.float32)
# low_resolution_samples = np.minimum(HiC_max_value, low_resolution_samples)
# high_resolution_samples = np.minimum(HiC_max_value, high_resolution_samples)
#low_resolution_samples = np.load(gzip.GzipFile('../../data/GM12878_replicate_down16_chr19_22.npy.gz', "r")).astype(np.float32) * down_sample_ratio
#high_resolution_samples = np.load(gzip.GzipFile('../../data/GM12878_replicate_original_chr19_22.npy.gz', "r")).astype(np.float32)
low_resolution_samples = np.load(gzip.GzipFile('/home/zhangyan/SRHiC_samples/IMR90_down_HINDIII16_chr1_8.npy.gz', "r")).astype(np.float32) * down_sample_ratio
high_resolution_samples = np.load(gzip.GzipFile('/home/zhangyan/SRHiC_samples/original10k/_IMR90_HindIII_original_chr1_8.npy.gz', "r")).astype(np.float32)
low_resolution_samples = np.minimum(HiC_max_value, low_resolution_samples)
high_resolution_samples = np.minimum(HiC_max_value, high_resolution_samples)
# Reshape the high-quality Hi-C sample as the target value of the training.
sample_size = low_resolution_samples.shape[-1]
padding = conv2d1_filters_size + conv2d2_filters_size + conv2d3_filters_size - 3
half_padding = padding / 2
output_length = sample_size - padding
Y = []
for i in range(high_resolution_samples.shape[0]):
no_padding_sample = high_resolution_samples[i][0][half_padding:(sample_size-half_padding) , half_padding:(sample_size - half_padding)]
Y.append(no_padding_sample)
Y = np.array(Y).astype(np.float32)
print low_resolution_samples.shape, Y.shape
lowres_set = data.TensorDataset(torch.from_numpy(low_resolution_samples), torch.from_numpy(np.zeros(low_resolution_samples.shape[0])))
lowres_loader = torch.utils.data.DataLoader(lowres_set, batch_size=batch_size, shuffle=False)
hires_set = data.TensorDataset(torch.from_numpy(Y), torch.from_numpy(np.zeros(Y.shape[0])))
hires_loader = torch.utils.data.DataLoader(hires_set, batch_size=batch_size, shuffle=False)
Net = model.Net(40, 28)
if use_gpu:
Net = Net.cuda()
optimizer = optim.SGD(Net.parameters(), lr = 0.00001)
_loss = nn.MSELoss()
Net.train()
running_loss = 0.0
running_loss_validate = 0.0
reg_loss = 0.0
# write the log file to record the training process
log = open('HindIII_train.txt', 'w')
for epoch in range(0, 100000):
for i, (v1, v2) in enumerate(zip(lowres_loader, hires_loader)):
if (i == len(lowres_loader) - 1):
continue
_lowRes, _ = v1
_highRes, _ = v2
_lowRes = Variable(_lowRes)
_highRes = Variable(_highRes)
if use_gpu:
_lowRes = _lowRes.cuda()
_highRes = _highRes.cuda()
optimizer.zero_grad()
y_prediction = Net(_lowRes)
loss = _loss(y_prediction, _highRes)
loss.backward()
optimizer.step()
running_loss += loss.data[0]
print '-------', i, epoch, running_loss/i, strftime("%Y-%m-%d %H:%M:%S", gmtime())
log.write(str(epoch) + ', ' + str(running_loss/i,) + '\n')
running_loss = 0.0
running_loss_validate = 0.0
# save the model every 100 epoches
if (epoch % 100 == 0):
torch.save(Net.state_dict(), '/home/zhangyan/pytorch_models/pytorch_HindIII_model_' + str(epoch))
pass
| [
"jb.morlot@gmail.com"
] | jb.morlot@gmail.com |
c01164af9c7f69565c52f1e9981eba91ae0937c1 | e6aaec60ebe2621d566bbbe37bac80ccbb06e11b | /Syntax/loops/while_loop.py | fff63a7c9b50ac4231f48f453f7860bfba369175 | [] | no_license | ZeweiChu/julyedu-python-datascience | 92acd4df3e50e77ed8f9b53cf6be508ef7fe14db | 016de0633bb1848e278bf87f715c0f1331f7bec8 | refs/heads/master | 2021-01-21T14:48:44.443313 | 2017-08-04T14:58:32 | 2017-08-04T14:58:32 | 95,336,260 | 6 | 6 | null | null | null | null | UTF-8 | Python | false | false | 91 | py | i = 0
while 1:
if i % 5 == 0:
i += 1
continue
print(i)
i += 1
if i >= 20:
break | [
"zeweichu@gmail.com"
] | zeweichu@gmail.com |
5229abb6be00316ff90cd09e352230cb2bc258fe | a2d5681a37be0d3b0753a0e979cb4fa7b0398f32 | /indexedcorpus.py | 84aa2ea572d830a6ae74aed8e35b0c416de90ad2 | [] | no_license | stephenroller/class-nlp-project | f7c09281336985ac55d25e886e7aa180e2225580 | 0362ec1182dc6d3ab54990bbb097339e7bc386a0 | refs/heads/master | 2020-05-29T23:26:56.024802 | 2011-05-13T18:30:49 | 2011-05-13T18:30:49 | 1,606,152 | 3 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,429 | py | #!/usr/bin/evn python
import sqlite3
import os
from itertools import groupby
from util import context_windows
class IndexedCorpus(object):
def __init__(self, indexfile, corpus_directory=''):
self.indexfile = indexfile
self.corpus_directory = corpus_directory
self.conn = sqlite3.connect(indexfile)
def get_unique_words(self):
c = self.conn.cursor()
c.execute('select word from words order by word');
for row in c:
yield row[0]
c.close()
def get_contexts(self, query):
c = self.conn.cursor()
c.execute('''
SELECT F.filename, WA.pos
FROM words AS W
JOIN word_appearances as WA ON (W.id = WA.word)
JOIN filenames AS F ON (WA.file = F.id)
WHERE W.word = ?
ORDER BY WA.file, WA.pos
''',
[query]
)
for filename, positions in groupby(c, lambda x: x[0]):
f = open(os.path.join(self.corpus_directory, filename))
for filename, position in positions:
f.seek(position)
line = f.readline().strip()
yield line
f.close()
c.close()
def __len__(self):
c = self.conn.cursor()
c.execute('select count(*) from words');
for row in c:
count = row[0]
c.close()
return count
| [
"roller@cs.utexas.edu"
] | roller@cs.utexas.edu |
25f2fdcf8501ff60ecd528b4ff6960f1f701ee22 | dd21064931d4b4829d8d2f1ec2623983e4ddb982 | /site/api/migrations/0012_order_cookingtime.py | d92293712fc160590d6b8252fe51245e60168388 | [] | no_license | qwaszx000/delivery_service | 43e30e286759e5dc4a8a4831cb3feefc842c33ae | 0ea8a35b3b709320f21079aa5ffd1c26e251aa4d | refs/heads/master | 2022-10-11T20:21:55.370370 | 2020-05-23T08:20:19 | 2020-05-23T08:20:19 | 263,871,405 | 0 | 0 | null | 2020-06-06T09:57:00 | 2020-05-14T09:28:17 | Python | UTF-8 | Python | false | false | 400 | py | # Generated by Django 3.0.6 on 2020-05-22 09:37
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('api', '0011_auto_20200522_1200'),
]
operations = [
migrations.AddField(
model_name='order',
name='CookingTime',
field=models.SmallIntegerField(blank=True, null=True),
),
]
| [
"kalita1303@gmail.com"
] | kalita1303@gmail.com |
43c88ceef22e3112a541ec05c8e4012ce4c8c0df | b43fefe3b2aae0d26304c30a858d8733859c7915 | /venv/bin/easy_install | 3e372d2a3dc61cb42284315489a4811389ff9162 | [] | no_license | nithinrithin/AI_Learning | 057b502c599835503ba627de54979bd43b5be4e8 | f6f9a075ad0c5d396e930a2fbd6a6bfd09a0bc4d | refs/heads/master | 2020-08-21T06:02:51.962175 | 2019-10-18T20:53:04 | 2019-10-18T20:53:04 | 216,104,802 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 444 | #!/home/nithin/PycharmProjects/AI_Learning/venv/bin/python
# EASY-INSTALL-ENTRY-SCRIPT: 'setuptools==40.8.0','console_scripts','easy_install'
__requires__ = 'setuptools==40.8.0'
import re
import sys
from pkg_resources import load_entry_point
if __name__ == '__main__':
sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
sys.exit(
load_entry_point('setuptools==40.8.0', 'console_scripts', 'easy_install')()
)
| [
"nithinrithin@gmail.com"
] | nithinrithin@gmail.com | |
c1fd09466b935364abbae55c332d08158db82ed2 | 545929b7663fc92f5526b9ff7ec8aeed0a84aa48 | /pro4.py | eb500ad525c72c85ad526ad792e1fbb985217a9c | [] | no_license | Tinasamayasundaram/propython | 2b58b8efc206a9b1ed87d44ad15703fa6e5c17f0 | 11a6a53b41421b74c9b639a70e698a2941445e8c | refs/heads/master | 2020-06-02T12:09:44.522032 | 2019-06-17T04:39:45 | 2019-06-17T04:39:45 | 191,150,025 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 189 | py | mt,jt=map(str,input().split())
s=0
if len(mt)>len(jt):
mt,jt=jt,mt
i=0
while i<len(mt):
s+=(ord(jt[i])-ord(mt[i]))
i+=1
for i in range(i,len(jt)):
s+=ord(jt[i])-ord('a')+1
print(s)
| [
"noreply@github.com"
] | Tinasamayasundaram.noreply@github.com |
c05cae9269daaa367bdbeffb4fb7053839861ce1 | 6a4abad6ff7c0d09d712b02a3970bc8b42097c0d | /backend/admin/__init__.py | fa19f778dba64f0984b0e729ac8062bca264344e | [] | no_license | kirya-dev/machine_advisor | 5c98c99e65276572f6299dd55064e59684379fc4 | 21fcf74a86ac9290adb9f120a4b64c87d68ab913 | refs/heads/master | 2022-12-12T12:07:48.403176 | 2018-06-05T17:53:34 | 2018-06-16T21:08:03 | 158,352,634 | 2 | 0 | null | 2022-09-16T17:53:02 | 2018-11-20T08:05:15 | JavaScript | UTF-8 | Python | false | false | 1,226 | py | from flask import render_template
from flask_admin import Admin, AdminIndexView, expose
from ..models.ar_model import ARModel
from ..models.ar_model_coeff import ARModelCoeff
from ..models.device import Device
from ..models.signal import Signal
from ..models.signal_sample import SignalSample
from ..models.type_signal import TypeSignal
from .. import app
from ..app import db
from .type_signal_view import TypeSignalView
from .signal_view import SignalView
from .signal_sample_view import SignalSampleView
from .ar_model_view import ARModelView
from .ar_model_coeff_view import ARModelCoeffView
from .device_view import DeviceView
admin = Admin(
app,
template_mode='bootstrap3',
index_view=AdminIndexView(
name='About',
template='admin/home.html',
url='/admin'
)
)
admin.add_view(TypeSignalView(TypeSignal, db.session, category='Signals'))
admin.add_view(SignalView(Signal, db.session, category='Signals'))
admin.add_view(SignalSampleView(SignalSample, db.session, category='Signals'))
admin.add_view(ARModelView(ARModel, db.session, category='Models'))
admin.add_view(ARModelCoeffView(ARModelCoeff, db.session, category='Models'))
admin.add_view(DeviceView(Device, db.session))
| [
"kirill.matasov@immelman.ru"
] | kirill.matasov@immelman.ru |
72de8eb136efd770ba9db06215d9ea846c6dd7c9 | ceb4ac75c40cd53f24d8f7e0a2f763de309bcfdb | /main4.py | 24ac83b28e32c4c98c305c1e1b012cf1ea9f8cf3 | [] | no_license | kevinelong/bo | c706d0771dbbf427a67d240f552eef4b7529b877 | e08e2d0e07e240cab440733173578f627e0f25ec | refs/heads/master | 2022-11-08T22:18:04.053714 | 2020-07-12T17:17:31 | 2020-07-12T17:17:31 | 279,112,257 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,184 | py | class Coordinate:
def __init__(self, x, y):
self.x = x
self.y = y
class Size:
def __init__(self, width, height):
self.width = width
self.height = height
class Box:
def __init__(self, origin:Coordinate, box_size:Size):
self.origin = origin
self.size = box_size
class Item:
def __init__(self, name:str, location:Box):
self.name = name
self.location = location if location is not None else Box(Coordinate(0,0), Size(3,3))
def __str__(self):
return f"{self.name} {self.location}"
class World:
def __init__(self):
self.item_list = []
self.bounds = Box(Coordinate(-10,-10), Size(20,20))
def value_at(self,x,y):
pixel = Item("",Box(Coordinate(x,y),Size(1,1)))
for item in self.item_list:
if self.have_collided(pixel,item):
return item.name
return "."
def __str__(self):
rows = []
origin = self.bounds.origin
for r in range(0,self.bounds.size.height):
row = []
for c in range(0,self.bounds.size.width):
row.append(self.value_at(c + origin.x, r + origin.y))
rows.append(" ".join(row))
return "\n".join(rows)
def add_item(self, item):
self.item_list.append(item)
def have_collided(self, item1, item2):
if item1.location.origin.x + item1.location.size.width <= item2.location.origin.x:
return False
if item2.location.origin.x + item2.location.size.width <= item1.location.origin.x:
return False
if item1.location.origin.y + item1.location.size.width <= item2.location.origin.y:
return False
if item2.location.origin.y + item2.location.size.width <= item1.location.origin.y:
return False
return True
def get_collisions(self):
collisions = []
for item1 in self.item_list:
for item2 in self.item_list:
if item1 != item2 and (item2,item1) not in collisions:
if self.have_collided(item1,item2):
collisions.append((item1,item2))
return collisions
debugging = True
def log(text):
if debugging:
print(text)
w = World()
add_item = lambda item: w.add_item(item)
get_collisions = lambda : w.get_collisions()
# TESTS
add_item(Item("A",Box(Coordinate(0,0), Size(3,3))))
add_item(Item("B",Box(Coordinate(-3,-3), Size(4,4))))
print(w)
c = get_collisions()
log(c)
assert( len(c) == 1 )
| [
"kevinelong@gmail.com"
] | kevinelong@gmail.com |
54b883b64ef60b20fe3d570fc00563c41892ba76 | 0bc8d6abec44e1187499f93803f82514f2b53fc6 | /Base/BaseReq1.py | fa5421d9d89f69e236d3949b433faf8e14ac7258 | [] | no_license | IamBiJav/auto_http_api | 932db2b4f2e1b67f2c0760806afd086494d92007 | 5a7ff01845e43d441fef8ae955b056085ab2dd10 | refs/heads/master | 2023-03-16T22:20:50.102610 | 2021-03-16T13:41:07 | 2021-03-16T13:41:07 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 4,054 | py | import requests
import json
import ast
from Base.BaseElementEnmu import Element
from Base.BaseParams import BaseFuzzParams
from Base.BaseStatistics import writeInfo
class Config(object):
def __init__(self, sessions):
self.sessions = sessions
def config_req(self, kw):
app = {}
header = {"Accept": "*/*", "Content-Type": "application/json;charset=utf-8"}
for item in kw:
url = "%s://%s" % (item["protocol"], item["url"])
print("==请求url:%s" % url)
print("==请求参数:%s" % item["params"])
params = "{}"
if item.get("params"):
params = item.get("params")
if item["method"] == "get":
res = self.sessions.get(url, data=json.dumps(ast.literal_eval(params)), headers=header, verify=False)
elif item["method"] == "post":
res = self.sessions.post(url, data=json.dumps(ast.literal_eval(params)), headers=header, verify=False)
else:
print("现在只针post和ge方法进行了测试，其他方法请自行扩展")
app["url"] = item["url"]
app["method"] = item["method"]
app["params"] = item["params"]
app["code"] = str(res.status_code)
app["msg"] = item["mark"]
app["hope"] = item.get("hope", "")
app["res"] = str(res.text)
app["ress"] = res # 传给检查函数进行解析
print("==响应结果:%s=" % app["res"])
app["result"] = self.__check(app["hope"], app["ress"])
print("==响应码:%s=" % app["code"])
writeInfo(app, Element.INFO_FILE)
def config_req_pict(self, kw, req=None):
app = {}
header = {"Accept": "*/*", "Content-Type": "application/json;charset=utf-8"}
for item in kw:
url = "%s://%s" % (item["protocol"], item["url"])
# 如果有参数才做模糊测试，没有做正向场景测试
if item.get("params"):
print("进行逆向场景测试")
params = BaseFuzzParams().param_fi(ast.literal_eval(item["params"]))
for i in params:
_info = ""
if i.get("info", "null") != "null":
_info = i.get("info", "参数正确")
i.pop("info")
if item["method"] == "get":
res = self.sessions.get(url, data=json.dumps(i), headers=header)
else:
res = self.sessions.post(url, data=json.dumps(i), headers=header)
app["url"] = item["url"]
app["method"] = item["method"]
app["params"] = str(i)
app["code"] = str(res.status_code)
app["msg"] = item["mark"] + "_" + _info
# app["hope"] = item.get("hope", "")
app["hope"] = ""
app["res"] = str(res.text)
app["result"] = ""
print("请求url:%s" % url)
print("请求参数:%s" % app["params"])
print("响应码:%s" % app["code"])
print("响应结果:%s" % app["res"])
writeInfo(app, Element.INFO_FILE)
else:
self.config_req(kw)
def __check(self, hope, res):
resp = json.dumps(json.loads(res.text), separators=(',', ':'))
is_check = 0 # 0表示期望值不存在，没有进行检查;1成功;-1失败
hopes = hope.split("|")
if len(hopes) and len(hope):
is_check = 1
# 循环检查期望值是否在实际值中能找到
for j in hopes:
if resp.find(j) == -1:
is_check = -1
break
if is_check == 0:
return "未检查"
elif is_check == 1:
return "成功"
else:
return "失败"
| [
"284772894@qq.com"
] | 284772894@qq.com |
9db0cb4a0ab5668893f4ed5fcb8d6a4515118cab | 9b64f0f04707a3a18968fd8f8a3ace718cd597bc | /huaweicloud-sdk-smn/huaweicloudsdksmn/v2/model/list_topics_item.py | 941aeb67db97af3db8459de64cdaa873c70458bf | [
"Apache-2.0"
] | permissive | jaminGH/huaweicloud-sdk-python-v3 | eeecb3fb0f3396a475995df36d17095038615fba | 83ee0e4543c6b74eb0898079c3d8dd1c52c3e16b | refs/heads/master | 2023-06-18T11:49:13.958677 | 2021-07-16T07:57:47 | 2021-07-16T07:57:47 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 5,993 | py | # coding: utf-8
import re
import six
class ListTopicsItem:
"""
Attributes:
openapi_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
"""
sensitive_list = []
openapi_types = {
'topic_urn': 'str',
'name': 'str',
'display_name': 'str',
'push_policy': 'int',
'enterprise_project_id': 'str'
}
attribute_map = {
'topic_urn': 'topic_urn',
'name': 'name',
'display_name': 'display_name',
'push_policy': 'push_policy',
'enterprise_project_id': 'enterprise_project_id'
}
def __init__(self, topic_urn=None, name=None, display_name=None, push_policy=None, enterprise_project_id=None):
"""ListTopicsItem - a model defined in huaweicloud sdk"""
self._topic_urn = None
self._name = None
self._display_name = None
self._push_policy = None
self._enterprise_project_id = None
self.discriminator = None
self.topic_urn = topic_urn
self.name = name
self.display_name = display_name
self.push_policy = push_policy
self.enterprise_project_id = enterprise_project_id
@property
def topic_urn(self):
"""Gets the topic_urn of this ListTopicsItem.
Topic的唯一的资源标识。
:return: The topic_urn of this ListTopicsItem.
:rtype: str
"""
return self._topic_urn
@topic_urn.setter
def topic_urn(self, topic_urn):
"""Sets the topic_urn of this ListTopicsItem.
Topic的唯一的资源标识。
:param topic_urn: The topic_urn of this ListTopicsItem.
:type: str
"""
self._topic_urn = topic_urn
@property
def name(self):
"""Gets the name of this ListTopicsItem.
创建topic的名字。
:return: The name of this ListTopicsItem.
:rtype: str
"""
return self._name
@name.setter
def name(self, name):
"""Sets the name of this ListTopicsItem.
创建topic的名字。
:param name: The name of this ListTopicsItem.
:type: str
"""
self._name = name
@property
def display_name(self):
"""Gets the display_name of this ListTopicsItem.
Topic的显示名，推送邮件消息时，作为邮件发件人显示。
:return: The display_name of this ListTopicsItem.
:rtype: str
"""
return self._display_name
@display_name.setter
def display_name(self, display_name):
"""Sets the display_name of this ListTopicsItem.
Topic的显示名，推送邮件消息时，作为邮件发件人显示。
:param display_name: The display_name of this ListTopicsItem.
:type: str
"""
self._display_name = display_name
@property
def push_policy(self):
"""Gets the push_policy of this ListTopicsItem.
消息推送的策略，该属性目前不支持修改，后续将支持修改。0表示发送失败，保留到失败队列，1表示直接丢弃发送失败的消息。
:return: The push_policy of this ListTopicsItem.
:rtype: int
"""
return self._push_policy
@push_policy.setter
def push_policy(self, push_policy):
"""Sets the push_policy of this ListTopicsItem.
消息推送的策略，该属性目前不支持修改，后续将支持修改。0表示发送失败，保留到失败队列，1表示直接丢弃发送失败的消息。
:param push_policy: The push_policy of this ListTopicsItem.
:type: int
"""
self._push_policy = push_policy
@property
def enterprise_project_id(self):
"""Gets the enterprise_project_id of this ListTopicsItem.
企业项目ID。
:return: The enterprise_project_id of this ListTopicsItem.
:rtype: str
"""
return self._enterprise_project_id
@enterprise_project_id.setter
def enterprise_project_id(self, enterprise_project_id):
"""Sets the enterprise_project_id of this ListTopicsItem.
企业项目ID。
:param enterprise_project_id: The enterprise_project_id of this ListTopicsItem.
:type: str
"""
self._enterprise_project_id = enterprise_project_id
def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.openapi_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
if attr in self.sensitive_list:
result[attr] = "****"
else:
result[attr] = value
return result
def to_str(self):
import simplejson as json
return json.dumps(self.to_dict())
def __repr__(self):
"""For `print` and `pprint`"""
return self.to_str()
def __eq__(self, other):
"""Returns true if both objects are equal"""
if not isinstance(other, ListTopicsItem):
return False
return self.__dict__ == other.__dict__
def __ne__(self, other):
"""Returns true if both objects are not equal"""
return not self == other
| [
"hwcloudsdk@huawei.com"
] | hwcloudsdk@huawei.com |
bdadcad105bd47878e489acf4fdde8994afe2523 | 566dad807a5bbfb86e67439271d174de016c352f | /snacks/admin.py | 2f809d937826574a0a27c5355f0f8938e7437e95 | [
"MIT"
] | permissive | YazanAhmad18/DjangoX | 4e4d0e4fba5ff6e5e87ce0967d530c75230cffc0 | 1e3316fff1f4b0e4fd4895e39564c8f4d36751c1 | refs/heads/master | 2023-07-13T09:44:49.188812 | 2021-09-01T14:26:20 | 2021-09-01T14:26:20 | 402,051,083 | 0 | 0 | NOASSERTION | 2021-09-01T14:26:21 | 2021-09-01T12:22:49 | Python | UTF-8 | Python | false | false | 116 | py | from django.contrib import admin
from .models import Snack
# Register your models here.
admin.site.register(Snack) | [
"yazan-ahmed1999a@outlook.com"
] | yazan-ahmed1999a@outlook.com |
1a8fc78bc1fea37a970c7420c33b41f45b732af7 | cf9799c79d6d03fa1d2033a854842a21c2368c5d | /LBCScrapper/LBCHouseScrapper.py | e68d4728eb87592a3b85d2a083d8c102d3ae4d10 | [] | no_license | alpharender/leboncoin_scrapper | 3eb2b94926e7e30fde904035b57aafd2ce73d6a5 | c491659bda544d81e5e35de18fd0d4a2f6526857 | refs/heads/master | 2022-03-22T09:23:29.325645 | 2019-02-18T22:34:18 | 2019-02-18T22:34:18 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 4,152 | py | from pprint import pprint
from LBCProperties.LBCDomTarget import LBCDomTarget
from LBCProperties.LBCArticle import LBCArticle
from LBCProperties.LBCQueryStringEnum import LBCQueryStringEnum
from LBCProperties.LBCQueryStringEnum import LBCQueryStringCitiesEnum
from LBCProperties.LBCHouseQueryString import LBCHouseQueryString
from LBCProperties.LBCPrice import LBCPrice as Price
from LBCProperties.LBCSquare import LBCSquare as Square
from LBCProperties.LBCRooms import LBCRooms as Rooms
from LBCProperties.LBCHouseProperties import LBCHouseProperties
from LBCScrapper import LBCScrapper
from bs4 import BeautifulSoup
import json
import re
class LBCHouseScrapper(LBCScrapper):
"""
LBCHouseScrapper is an object for scrappping Le Bon Coin real estate.
:param location: The location to search
:type location: LBCQueryStringCitiesEnum
:param house_properties: The house properties
:type house_properties: LBCHouseProperties
:param query_string: The query string for url
:type query_string: LBCQueryString
"""
def __init__(self, location, house_properties):
super().__init__(location)
self.location = location
self.house_properties = house_properties
self.query_string = LBCHouseQueryString(self.location)
def parse_articles(self):
pass
def get_articles(self):
"""
Get articles method scrap all pages of Le Bon Coin articles
:returns: A list of LBCArticle objects
:rtype: list
"""
increment = 0
titles = []
prices = []
locations = []
links = []
while True:
url = self.query_string.increment(self.url, increment)
request = self.session.get(url)
scrapper = BeautifulSoup(request.text, "html.parser")
articles = scrapper.find_all("li", class_=LBCDomTarget.ARTICLE.value)
if len(articles) == 0:
break
increment += 1
print(url)
titles.append(self.get_titles(articles))
prices.append(self.get_prices(articles))
locations.append(self.get_locations(articles))
links.append(self.get_links(articles))
self.last_pid = increment
for title, price, location, link in zip(self._merge_lists(titles), self._merge_lists(prices),
self._merge_lists(locations), self._merge_lists(links)):
self.articles.append(
LBCArticle(title, price, location, link)
)
return self.articles
def get_titles(self, articles):
titles = []
for article in articles:
titles.append(
article.find("span", {"data-qa-id": "aditem_title"}).text
)
return titles
def get_prices(self, articles):
prices = []
for article in articles:
prices.append(
re.search(r'^\d*', article.find("span", class_=LBCDomTarget.PRICE.value).text).group(0)
)
return prices
def get_locations(self, articles):
locations = []
for article in articles:
locations.append(
article.find("p", LBCDomTarget.LOCATION.value).text
)
return locations
def get_links(self, articles):
links = []
for article in articles:
links.append(
self.url[:-1] + article.find("a").attrs.get('href')
)
return links
if __name__ == '__main__':
location = LBCQueryStringCitiesEnum.AVIGNON.value
house_properties = LBCHouseProperties(Price(0, 100), Rooms(0, 100), Square(0, 100))
lbs = LBCHouseScrapper(location, house_properties)
lbs.get_articles()
lbs.store_to_json() | [
"cardiox1212@hotmail.fr"
] | cardiox1212@hotmail.fr |
157272d28612be329618c7942ab668c8d37b06d2 | f6abebf3625b7d5432c7524fbbe17e3073049d0a | /see_fields/__manifest__.py | 1ac3b863c79ed5e314b2ec5d297311685e3f6cb7 | [] | no_license | xmarts/modules_bazar | 6b6b9e343a8c795fdcee55e593328849b87f4f5f | edbc4cbd4b52901c7c72bc148025948ddb3a4e1e | refs/heads/master | 2020-04-24T17:12:48.663527 | 2019-02-22T21:55:20 | 2019-02-22T21:55:20 | 172,138,690 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 510 | py | # -*- coding: utf-8 -*-
# Part of Odoo. See LICENSE file for full copyright and licensing details.
{
'name' : 'Hidde fields product',
'summary': 'Ver campos de productos ocultos por variante',
'description': """
Ver campos de productos ocultos por variante
""",
'author': "Xmarts, Nayeli Valencia Díaz",
'website': "http://www.xmarts.com",
'depends': ['base','product','stock_account','product_margin'],
'data': [
'views/views.xml',
'views/templates.xml',
]
}
| [
"ogapablo1995@gmail.com"
] | ogapablo1995@gmail.com |
a516d2875aaf6433dbddd6f1230011d83645a1b2 | 7d91ad2e89863266e533da3e256620481608e539 | /inasistencias/templatetags/faltas.py | bbfa78cefa593eaf6bfa48921fa7abb9e325c93e | [] | no_license | LuchoCastillo/RDFvevo | b7be3734d64519b83c419993dc54d5f19c5783b8 | e42bdc72a33b3e213455e37adb34febe17c6125f | refs/heads/master | 2021-01-19T13:00:49.446395 | 2014-12-01T14:41:32 | 2014-12-01T14:41:32 | 27,383,432 | 0 | 1 | null | null | null | null | UTF-8 | Python | false | false | 872 | py | from django import template
from inasistencias.models import Alumno, Inasistencia
register = template.Library()
@register.simple_tag
def chequear(alumno, fecha, tipo):
dic = {
'P': 0,
'1/2': 0.5,
'1/4': 0.25,
'3/4': 0.75,
'A': 1,
}
fecha = formatear_fecha(fecha)
falta = Inasistencia.objects.filter(alumno=alumno).filter(fecha=fecha)
# Si existe una falta de ese alumno en esa fecha
if falta:
# Si el tipo de falta coincide activa esa opcion
if dic[tipo] == falta[0].tipo:
return 'checked'
else:
return ''
# Si no hay falta para esa fecha y la opcion es presente
elif tipo == 'P':
# Se activa
return 'checked'
else:
return ''
def formatear_fecha(fecha):
if fecha.find('/') != -1:
f = fecha.split('/')
return f[2] + '-' + f[1] + '-' + f[0]
else:
return fecha | [
"luciano@linux-lc.site"
] | luciano@linux-lc.site |
c4a9a30a22a68f25af0d217da63c120ae63b9e2a | 3bbc96ed812a20d7cd3bb81821da132a0e00142b | /src/gui_L087 (for C1_PRO_X18 camera)/main.py | d78cb8db6458236e7ac996d2b028f24971360534 | [
"MIT"
] | permissive | thiwankajayasiri/SCF4-SDK | ab48e6b41d7aa924c10793ec1d8cb64754e0ce17 | e804257083d821ba48daed9896cb99a91fc293bc | refs/heads/master | 2023-06-11T21:44:11.924694 | 2021-07-02T11:03:46 | 2021-07-02T11:03:46 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 20,088 | py | import sys
import os
from PyQt5 import QtCore, QtGui, QtWidgets, uic
from PyQt5 import sip
from PyQt5.QtCore import Qt, QTimer, QThread
import queue
import utils
import hw_serial
import gui
import version
if sys.platform == 'win32':
QtWidgets.QApplication.setAttribute(QtCore.Qt.AA_EnableHighDpiScaling, True)
SETTINGS_FILE = 'settings.json'
MOVE_REL = 0
MOVE_ABS = 1
# print(sys.version)
if os.name == 'nt':
from serial.tools.list_ports_windows import *
elif sys.platform == 'darwin':
from serial.tools.list_ports_osx import *
from serial.tools.list_ports_vid_pid_osx_posix import *
elif os.name == 'posix':
from serial.tools.list_ports_posix import *
from serial.tools.list_ports_vid_pid_osx_posix import *
else:
raise ImportError("Serial error: no implementation for your platform ('%s') available" % (os.name,))
ser = serial.Serial()
q = queue.Queue()
q_labels = queue.Queue()
running = True
class MyWindowClass(QtWidgets.QMainWindow, gui.Ui_MainWindow):
def __init__(self, parent=None):
QtWidgets.QMainWindow.__init__(self, parent)
self.setupUi(self)
self.original_window_name = self.windowTitle()
self.setWindowTitle(self.original_window_name + " (" + version.__version__ + ")")
pixmap = QtGui.QPixmap('camera.jpg')
pixmap = pixmap.scaled(160, 200, Qt.KeepAspectRatio, Qt.SmoothTransformation)
self.label_picture.setPixmap(pixmap)
self.resize(400, 400) # make main window as small as possible
self.config = {}
self.config = utils.json_boot_routine(SETTINGS_FILE)
self.feedback = []
self.controls_enabled = False
self.move_mode = MOVE_REL
# get available com ports
self.combo_ports.clear()
com_ports = sorted(comports())
for port, desc, hwid in com_ports:
self.combo_ports.addItem(port.strip())
# set last selected com port
self.combo_ports.setCurrentIndex(self.combo_ports.findText(self.config["port"]))
# setup serial class
self.hw = hw_serial.SerialComm()
self.thread_serial = QThread()
self.hw.strStatus.connect(self.serStatus)
self.hw.strVersion.connect(self.serVersion)
self.hw.strVoltage.connect(self.serVoltage)
self.hw.feedback.connect(self.serFeedback)
self.hw.moveToThread(self.thread_serial)
self.thread_serial.started.connect(self.hw.serial_worker)
self.thread_serial.start()
#self.config["saved_points"] = []
if self.config["enable_save_keypoint_button"] == True:
self.push_save_go.show()
else:
self.push_save_go.hide()
self.slider_a_speed.setMinimum(self.config["speed_min"])
self.slider_a_speed.setMaximum(self.config["speed_max"])
self.slider_a_speed.setValue(self.config["speed_default"])
self.slider_a_speed.valueChanged.connect(self.slider_a_speed_changed)
self.slider_b_speed.setMinimum(self.config["speed_min"])
self.slider_b_speed.setMaximum(self.config["speed_max"])
self.slider_b_speed.setValue(self.config["speed_default"])
self.slider_b_speed.valueChanged.connect(self.slider_b_speed_changed)
self.slider_c_speed.setMinimum(self.config["speed_min"])
self.slider_c_speed.setMaximum(self.config["speed_max"])
self.slider_c_speed.setValue(self.config["speed_default"])
self.slider_c_speed.valueChanged.connect(self.slider_c_speed_changed)
# buttons
self.btn_connect.clicked.connect(self.btn_connect_clicked)
self.btn_disconnect.clicked.connect(self.btn_disconnect_clicked)
self.btn_dn1.clicked.connect(self.btn_dn1_clicked)
self.btn_dn2.clicked.connect(self.btn_dn2_clicked)
self.btn_aux_on.clicked.connect(self.btn_aux_on_clicked)
self.btn_aux_off.clicked.connect(self.btn_aux_off_clicked)
self.push_save_go.clicked.connect(self.push_save_go_clicked)
self.btn_a_left.clicked.connect(self.btn_a_left_clicked)
self.btn_a_right.clicked.connect(self.btn_a_right_clicked)
self.btn_b_left.clicked.connect(self.btn_b_left_clicked)
self.btn_b_right.clicked.connect(self.btn_b_right_clicked)
self.btn_c_left.clicked.connect(self.btn_c_left_clicked)
self.btn_c_right.clicked.connect(self.btn_c_right_clicked)
self.btn_a_left_fine.clicked.connect(self.btn_a_left_fine_clicked)
self.btn_a_right_fine.clicked.connect(self.btn_a_right_fine_clicked)
self.btn_b_left_fine.clicked.connect(self.btn_b_left_fine_clicked)
self.btn_b_right_fine.clicked.connect(self.btn_b_right_fine_clicked)
self.btn_c_left_fine.clicked.connect(self.btn_c_left_fine_clicked)
self.btn_c_right_fine.clicked.connect(self.btn_c_right_fine_clicked)
self.btn_a_0.clicked.connect(self.btn_a_0_clicked)
self.btn_b_0.clicked.connect(self.btn_b_0_clicked)
self.btn_c_0.clicked.connect(self.btn_c_0_clicked)
self.btn_a_stop.clicked.connect(self.btn_a_stop_clicked)
self.btn_b_stop.clicked.connect(self.btn_b_stop_clicked)
self.btn_c_stop.clicked.connect(self.btn_c_stop_clicked)
self.btn_a_seek.clicked.connect(self.btn_a_seek_clicked)
self.btn_b_seek.clicked.connect(self.btn_b_seek_clicked)
self.btn_c_seek.clicked.connect(self.btn_c_seek_clicked)
self.push_pr1_set.clicked.connect(self.push_pr1_set_clicked)
self.push_pr2_set.clicked.connect(self.push_pr2_set_clicked)
self.push_pr3_set.clicked.connect(self.push_pr3_set_clicked)
self.push_pr4_set.clicked.connect(self.push_pr4_set_clicked)
self.push_pr5_set.clicked.connect(self.push_pr5_set_clicked)
self.push_pr1_go.clicked.connect(self.push_pr1_go_clicked)
self.push_pr2_go.clicked.connect(self.push_pr2_go_clicked)
self.push_pr3_go.clicked.connect(self.push_pr3_go_clicked)
self.push_pr4_go.clicked.connect(self.push_pr4_go_clicked)
self.push_pr5_go.clicked.connect(self.push_pr5_go_clicked)
self.btn_pi_led_on.clicked.connect(self.btn_pi_led_on_clicked)
self.btn_pi_led_off.clicked.connect(self.btn_pi_led_off_clicked)
# Load presets
self.label_pr1_a.setText(str(self.config["presets"]["1"]["A"]))
self.label_pr1_b.setText(str(self.config["presets"]["1"]["B"]))
self.label_pr1_c.setText(str(self.config["presets"]["1"]["C"]))
self.label_pr2_a.setText(str(self.config["presets"]["2"]["A"]))
self.label_pr2_b.setText(str(self.config["presets"]["2"]["B"]))
self.label_pr2_c.setText(str(self.config["presets"]["2"]["C"]))
self.label_pr3_a.setText(str(self.config["presets"]["3"]["A"]))
self.label_pr3_b.setText(str(self.config["presets"]["3"]["B"]))
self.label_pr3_c.setText(str(self.config["presets"]["3"]["C"]))
self.label_pr4_a.setText(str(self.config["presets"]["4"]["A"]))
self.label_pr4_b.setText(str(self.config["presets"]["4"]["B"]))
self.label_pr4_c.setText(str(self.config["presets"]["4"]["C"]))
self.label_pr5_a.setText(str(self.config["presets"]["5"]["A"]))
self.label_pr5_b.setText(str(self.config["presets"]["5"]["B"]))
self.label_pr5_c.setText(str(self.config["presets"]["5"]["C"]))
self.slider_a.sliderReleased.connect(self.slider_a_released)
self.slider_b.sliderReleased.connect(self.slider_b_released)
self.slider_c.sliderReleased.connect(self.slider_c_released)
self.slider_a.valueChanged.connect(self.slider_a_changed)
self.slider_b.valueChanged.connect(self.slider_b_changed)
self.slider_c.valueChanged.connect(self.slider_c_changed)
def slider_a_speed_changed(self, val):
self.label_a_speed.setText(str(val))
self.hw.send("M240 A" + str(val) + "\r\n")
self.config["current"]["A"]["speed"] = val
def slider_b_speed_changed(self, val):
self.label_b_speed.setText(str(val))
self.hw.send("M240 B" + str(val) + "\r\n")
self.config["current"]["B"]["speed"] = val
def slider_c_speed_changed(self, val):
self.label_c_speed.setText(str(val))
self.hw.send("M240 C" + str(val) + "\r\n")
self.config["current"]["C"]["speed"] = val
def slider_a_changed(self, val):
self.label_a_setpos.setText(str(val))
def slider_b_changed(self, val):
self.label_b_setpos.setText(str(val))
def slider_c_changed(self, val):
self.label_c_setpos.setText(str(val))
def slider_a_released(self):
pos = self.slider_a.value()
self.set_move_mode(MOVE_ABS)
self.hw.send("G0 A" + str(pos) + "\r\n")
def slider_b_released(self):
pos = self.slider_b.value()
self.set_move_mode(MOVE_ABS)
self.hw.send("G0 B" + str(pos) + "\r\n")
def slider_c_released(self):
pos = self.slider_c.value()
self.set_move_mode(MOVE_ABS)
self.hw.send("G0 C" + str(pos) + "\r\n")
def btn_pi_led_on_clicked(self):
self.hw.send("M238\r\n")
def btn_pi_led_off_clicked(self):
self.hw.send("M239\r\n")
def btn_aux_on_clicked(self):
self.hw.send("M246\r\n")
def btn_aux_off_clicked(self):
self.hw.send("M245\r\n")
def set_move_mode(self, mode):
self.move_mode = mode
if self.move_mode == MOVE_ABS:
self.hw.send("G90\r\n")
if self.move_mode == MOVE_REL:
self.hw.send("G91\r\n")
def controls_enable(self, status):
# not enabled and instructed to enable
if not self.controls_enabled and status:
self.group_a.setEnabled(True)
self.group_b.setEnabled(True)
#self.group_c.setEnabled(True)
self.group_d.setEnabled(True)
#self.group_aux.setEnabled(True)
self.group_pi.setEnabled(True)
self.group_p1.setEnabled(True)
self.group_p2.setEnabled(True)
self.group_p3.setEnabled(True)
self.group_p4.setEnabled(True)
self.group_p5.setEnabled(True)
self.controls_enabled = True
# enabled and instructed to disable
if self.controls_enabled and not status:
self.group_a.setEnabled(False)
self.group_b.setEnabled(False)
#self.group_c.setEnabled(False)
self.group_d.setEnabled(False)
#self.group_aux.setEnabled(False)
self.group_pi.setEnabled(False)
self.group_p1.setEnabled(False)
self.group_p2.setEnabled(False)
self.group_p3.setEnabled(False)
self.group_p4.setEnabled(False)
self.group_p5.setEnabled(False)
self.controls_enabled = False
def set_controls(self, data):
self.progress_a.setValue(data[0])
self.progress_b.setValue(data[1])
self.progress_c.setValue(data[2])
self.label_a_pos.setText(str(data[0]))
self.label_b_pos.setText(str(data[1]))
self.label_c_pos.setText(str(data[2]))
self.label_a_limitsw.setText(str(data[3]))
self.label_b_limitsw.setText(str(data[4]))
self.label_c_limitsw.setText(str(data[5]))
self.label_a_status.setText(str(data[6]))
self.label_b_status.setText(str(data[7]))
self.label_c_status.setText(str(data[8]))
self.config["current"]["A"]["pos"] = data[0]
self.config["current"]["B"]["pos"] = data[1]
self.config["current"]["C"]["pos"] = data[2]
def btn_connect_clicked(self):
self.config["port"] = self.combo_ports.currentText()
self.hw.connect(self.config["port"], 115200, self.config["seek_timeout"])
def btn_disconnect_clicked(self):
self.hw.disconnect()
def btn_dn1_clicked(self):
self.hw.send("M8\r\n")
def btn_dn2_clicked(self):
self.hw.send("M7\r\n")
def btn_a_left_clicked(self):
self.set_move_mode(MOVE_REL)
self.hw.send("G0 A-" + str(self.config["defaults"]["A"]["jog_steps"]) + "\r\n")
def btn_a_right_clicked(self):
self.set_move_mode(MOVE_REL)
self.hw.send("G0 A" + str(self.config["defaults"]["A"]["jog_steps"]) + "\r\n")
def btn_b_left_clicked(self):
self.set_move_mode(MOVE_REL)
self.hw.send("G0 B-" + str(self.config["defaults"]["B"]["jog_steps"]) + "\r\n")
def btn_b_right_clicked(self):
self.set_move_mode(MOVE_REL)
self.hw.send("G0 B" + str(self.config["defaults"]["B"]["jog_steps"]) + "\r\n")
def btn_c_left_clicked(self):
self.set_move_mode(MOVE_REL)
self.hw.send("G0 C-" + str(self.config["defaults"]["C"]["jog_steps"]) + "\r\n")
def btn_c_right_clicked(self):
self.set_move_mode(MOVE_REL)
self.hw.send("G0 C" + str(self.config["defaults"]["C"]["jog_steps"]) + "\r\n")
def btn_a_left_fine_clicked(self):
self.set_move_mode(MOVE_REL)
self.hw.send("G0 A-" + str(self.config["defaults"]["A"]["jog_steps_fine"]) + "\r\n")
def btn_a_right_fine_clicked(self):
self.set_move_mode(MOVE_REL)
self.hw.send("G0 A" + str(self.config["defaults"]["A"]["jog_steps_fine"]) + "\r\n")
def btn_b_left_fine_clicked(self):
self.set_move_mode(MOVE_REL)
self.hw.send("G0 B-" + str(self.config["defaults"]["B"]["jog_steps_fine"]) + "\r\n")
def btn_b_right_fine_clicked(self):
self.set_move_mode(MOVE_REL)
self.hw.send("G0 B" + str(self.config["defaults"]["B"]["jog_steps_fine"]) + "\r\n")
def btn_c_left_fine_clicked(self):
self.set_move_mode(MOVE_REL)
self.hw.send("G0 C-" + str(self.config["defaults"]["C"]["jog_steps_fine"]) + "\r\n")
def btn_c_right_fine_clicked(self):
self.set_move_mode(MOVE_REL)
self.hw.send("G0 C" + str(self.config["defaults"]["C"]["jog_steps_fine"]) + "\r\n")
def btn_a_0_clicked(self):
self.hw.send("G92 A32000\r\n")
def btn_b_0_clicked(self):
self.hw.send("G92 B32000\r\n")
def btn_c_0_clicked(self):
self.hw.send("G92 C32000\r\n")
def btn_a_stop_clicked(self):
self.hw.send("M0 A\r\n")
def btn_b_stop_clicked(self):
self.hw.send("M0 B\r\n")
def btn_c_stop_clicked(self):
self.hw.send("M0 C\r\n")
def btn_a_seek_clicked(self):
self.hw.action_recipe.put("seek_a")
self.btn_a_seek.setStyleSheet('')
def btn_b_seek_clicked(self):
self.hw.action_recipe.put("seek_b")
self.btn_b_seek.setStyleSheet('')
def btn_c_seek_clicked(self):
self.hw.action_recipe.put("seek_c")
self.btn_c_seek.setStyleSheet('')
def push_pr1_set_clicked(self):
self.config["presets"]["1"]["A"] = self.config["current"]["A"]["pos"]
self.config["presets"]["1"]["B"] = self.config["current"]["B"]["pos"]
self.config["presets"]["1"]["C"] = self.config["current"]["C"]["pos"]
self.label_pr1_a.setText(str(self.config["presets"]["1"]["A"]))
self.label_pr1_b.setText(str(self.config["presets"]["1"]["B"]))
self.label_pr1_c.setText(str(self.config["presets"]["1"]["C"]))
def push_pr2_set_clicked(self):
self.config["presets"]["2"]["A"] = self.config["current"]["A"]["pos"]
self.config["presets"]["2"]["B"] = self.config["current"]["B"]["pos"]
self.config["presets"]["2"]["C"] = self.config["current"]["C"]["pos"]
self.label_pr2_a.setText(str(self.config["presets"]["2"]["A"]))
self.label_pr2_b.setText(str(self.config["presets"]["2"]["B"]))
self.label_pr2_c.setText(str(self.config["presets"]["2"]["C"]))
def push_pr3_set_clicked(self):
self.config["presets"]["3"]["A"] = self.config["current"]["A"]["pos"]
self.config["presets"]["3"]["B"] = self.config["current"]["B"]["pos"]
self.config["presets"]["3"]["C"] = self.config["current"]["C"]["pos"]
self.label_pr3_a.setText(str(self.config["presets"]["3"]["A"]))
self.label_pr3_b.setText(str(self.config["presets"]["3"]["B"]))
self.label_pr3_c.setText(str(self.config["presets"]["3"]["C"]))
def push_pr4_set_clicked(self):
self.config["presets"]["4"]["A"] = self.config["current"]["A"]["pos"]
self.config["presets"]["4"]["B"] = self.config["current"]["B"]["pos"]
self.config["presets"]["4"]["C"] = self.config["current"]["C"]["pos"]
self.label_pr4_a.setText(str(self.config["presets"]["4"]["A"]))
self.label_pr4_b.setText(str(self.config["presets"]["4"]["B"]))
self.label_pr4_c.setText(str(self.config["presets"]["4"]["C"]))
def push_pr5_set_clicked(self):
self.config["presets"]["5"]["A"] = self.config["current"]["A"]["pos"]
self.config["presets"]["5"]["B"] = self.config["current"]["B"]["pos"]
self.config["presets"]["5"]["C"] = self.config["current"]["C"]["pos"]
self.label_pr5_a.setText(str(self.config["presets"]["5"]["A"]))
self.label_pr5_b.setText(str(self.config["presets"]["5"]["B"]))
self.label_pr5_c.setText(str(self.config["presets"]["5"]["C"]))
def push_pr1_go_clicked(self):
self.set_move_mode(MOVE_ABS)
self.hw.send("G0 A" + str(self.config["presets"]["1"]["A"]) + " B" + str(self.config["presets"]["1"]["B"]) + " C" + str(self.config["presets"]["1"]["C"]) + "\r\n")
def push_pr2_go_clicked(self):
self.set_move_mode(MOVE_ABS)
self.hw.send("G0 A" + str(self.config["presets"]["2"]["A"]) + " B" + str(self.config["presets"]["2"]["B"]) + " C" + str(self.config["presets"]["2"]["C"]) + "\r\n")
def push_pr3_go_clicked(self):
self.set_move_mode(MOVE_ABS)
self.hw.send("G0 A" + str(self.config["presets"]["3"]["A"]) + " B" + str(self.config["presets"]["3"]["B"]) + " C" + str(self.config["presets"]["3"]["C"]) + "\r\n")
def push_pr4_go_clicked(self):
self.set_move_mode(MOVE_ABS)
self.hw.send("G0 A" + str(self.config["presets"]["4"]["A"]) + " B" + str(self.config["presets"]["4"]["B"]) + " C" + str(self.config["presets"]["4"]["C"]) + "\r\n")
def push_pr5_go_clicked(self):
self.set_move_mode(MOVE_ABS)
self.hw.send("G0 A" + str(self.config["presets"]["5"]["A"]) + " B" + str(self.config["presets"]["5"]["B"]) + " C" + str(self.config["presets"]["5"]["C"]) + "\r\n")
def push_save_go_clicked(self):
print("KP:", self.label_a_pos.text(), self.label_b_pos.text())
#pos = (float(self.label_a_pos.text()), float(self.label_b_pos.text()))
#self.config["saved_points"].append(pos)
def closeEvent(self, event):
global config
global running
utils.json_exit_routine(SETTINGS_FILE, self.config)
running = False
def serStatus(self, text):
self.label_ser_status.setText(text)
if text == "Connected":
self.combo_ports.setEnabled(False)
self.btn_connect.setEnabled(False)
self.btn_disconnect.setEnabled(True)
self.hw.action_recipe.put("init")
self.hw.action_recipe.put("version")
self.hw.action_recipe.put("status1")
self.hw.action_recipe.put("voltage")
if text == "Disconnected":
self.combo_ports.setEnabled(True)
self.btn_connect.setEnabled(True)
self.btn_disconnect.setEnabled(False)
self.controls_enable(False)
def serVersion(self, text):
self.label_ser_version.setText(text)
def serVoltage(self, text):
if text.find("ADC") >= 0:
v = (float)(text.split("=")[1])
v = v/4096.0*3.3/0.5
#self.label_voltage.setText(str(round(v, 2)).format(2))
self.label_voltage.setText('VUSB={0:01.1f}V'.format(v))
def serFeedback(self, data):
if len(data) == 9:
self.controls_enable(True)
self.feedback = data
self.set_controls(data)
app = QtWidgets.QApplication(sys.argv)
myWindow = MyWindowClass(None)
myWindow.show()
app.exec_()
| [
"info@kurokesu.com"
] | info@kurokesu.com |
7f7621b29075cba866d4c2b7508de19821719201 | 2c6bc39f2adf3731109519bfaf8a3a24ae913834 | /admin/admin/settings.py | 60c38e44516af552aee83c9bf875de446377cff1 | [] | no_license | aliensmart/django-admin | a1289e1a01d64b416f64db1ed435ba23f4c2b8ca | 0732358e4ace57abbf621df66c75b85219226d07 | refs/heads/master | 2022-09-01T15:28:54.664846 | 2020-05-20T20:34:54 | 2020-05-20T20:34:54 | 265,679,957 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 3,085 | py | """
Django settings for admin project.
Generated by 'django-admin startproject' using Django 3.0.6.
For more information on this file, see
https://docs.djangoproject.com/en/3.0/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/3.0/ref/settings/
"""
import os
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.0/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = 'y*wb35kj$9zpphxs5r)@*t)mer@+zc#6fol0ho29$#cis8r*ai'
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True
ALLOWED_HOSTS = []
# Application definition
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
]
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
ROOT_URLCONF = 'admin.urls'
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]
WSGI_APPLICATION = 'admin.wsgi.application'
# Database
# https://docs.djangoproject.com/en/3.0/ref/settings/#databases
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
}
}
# Password validation
# https://docs.djangoproject.com/en/3.0/ref/settings/#auth-password-validators
AUTH_PASSWORD_VALIDATORS = [
{
'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
},
]
# Internationalization
# https://docs.djangoproject.com/en/3.0/topics/i18n/
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'
USE_I18N = True
USE_L10N = True
USE_TZ = True
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/3.0/howto/static-files/
STATIC_URL = '/static/'
| [
"kaoua17@gmail.com"
] | kaoua17@gmail.com |
07cab7f377e53810bca7f3ea6fd25e8f93c45bf2 | ae7884af1ec3965b7c0eec22edad6b74f78b7ba6 | /server/src/uds/core/workers/stats_collector.py | 23a2506832f5b1b824b8e41f3fa32e05c785c451 | [] | no_license | glyptodon/openuds | f4eefa319a3ead827dad999d24e5ee3854d1345d | 3908c875d30ec332490fc8c049bb537e10f10d08 | refs/heads/master | 2021-07-12T20:58:49.281242 | 2021-03-05T22:42:55 | 2021-03-05T22:42:55 | 62,921,174 | 0 | 1 | null | 2016-07-08T22:33:44 | 2016-07-08T22:33:44 | null | UTF-8 | Python | false | false | 4,456 | py | # -*- coding: utf-8 -*-
#
# Copyright (c) 2013-2020 Virtual Cable S.L.U.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without modification,
# are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyright notice,
# this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation
# and/or other materials provided with the distribution.
# * Neither the name of Virtual Cable S.L. nor the names of its contributors
# may be used to endorse or promote products derived from this software
# without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"""
@author: Adolfo Gómez, dkmaster at dkmon dot com
"""
import logging
import typing
from uds.models import ServicePool, Authenticator
from uds.core.util.state import State
from uds.core.util.stats import counters
from uds.core.managers import statsManager
from uds.core.jobs import Job
logger = logging.getLogger(__name__)
class DeployedServiceStatsCollector(Job):
"""
This Job is responsible for collecting stats for every deployed service every ten minutes
"""
frecuency = 599 # Once every ten minutes, 601 is prime, 599 also is prime
friendly_name = 'Deployed Service Stats'
def run(self):
logger.debug('Starting Deployed service stats collector')
servicePoolsToCheck: typing.Iterable[ServicePool] = ServicePool.objects.filter(
state=State.ACTIVE
).iterator()
for servicePool in servicePoolsToCheck:
try:
fltr = servicePool.assignedUserServices().exclude(
state__in=State.INFO_STATES
)
assigned = fltr.count()
inUse = fltr.filter(in_use=True).count()
counters.addCounter(servicePool, counters.CT_ASSIGNED, assigned)
counters.addCounter(servicePool, counters.CT_INUSE, inUse)
except Exception:
logger.exception(
'Getting counters for service pool %s', servicePool.name
)
for auth in Authenticator.objects.all():
fltr = auth.users.filter(userServices__isnull=False).exclude(
userServices__state__in=State.INFO_STATES
)
users = auth.users.all().count()
users_with_service = fltr.distinct().count()
number_assigned_services = fltr.count()
counters.addCounter(auth, counters.CT_AUTH_USERS, users)
counters.addCounter(
auth, counters.CT_AUTH_SERVICES, number_assigned_services
)
counters.addCounter(
auth, counters.CT_AUTH_USERS_WITH_SERVICES, users_with_service
)
logger.debug('Done Deployed service stats collector')
class StatsCleaner(Job):
"""
This Job is responsible of housekeeping of stats tables.
This is done by:
* Deleting all records
* Optimize table
"""
frecuency = 3600 * 24 * 15 # Ejecuted just once every 15 days
friendly_name = 'Statistic housekeeping'
def run(self):
logger.debug('Starting statistics cleanup')
try:
statsManager().cleanupCounters()
except Exception:
logger.exception('Cleaning up counters')
try:
statsManager().cleanupEvents()
except Exception:
logger.exception('Cleaning up events')
logger.debug('Done statistics cleanup')
| [
"dkmaster@dkmon.com"
] | dkmaster@dkmon.com |
115c7c7c5a07a0ed5e1214fc406d01cf55ee2eef | f1267f4a0fae414f16b2429a5c3b1cbd42df8794 | /lib/Daemon.py | dded7072b2770aaa31cf9b096453386af2a21d63 | [] | no_license | oraant/learn_zabbix_odbm | 3ff3b0318e802ebff9603c8daefdf67cda772b94 | 35a010b5dc0a8bc2989b4d3618f795b08a637063 | refs/heads/master | 2020-12-24T05:46:10.358982 | 2016-03-21T10:25:29 | 2016-03-21T10:25:29 | 73,452,172 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,800 | py | # coding:utf-8
import sys,os
class Daemon:
def __init__(self,stdin='/dev/null',stdout='/dev/null', stderr='dev/null'):
'''初始化，指定标准输入输出文件'''
self.stdin = stdin
self.stdout = stdout
self.stderr = stderr
def daemonize(self):
'''Fork当前进程为守护进程，重定向标准文件描述符'''
#Perform first fork.
try:
pid = os.fork()
if pid > 0:
sys.exit(0) #first parent out
except OSError, e:
sys.stderr.write("fork #1 failed: (%d) %s\n" %(e.errno, e.strerror))
sys.exit(1)
#从母体环境脱离，更改路径，更改默认权限，以及创建新的SESSION（为了摆脱控制终端，防止响应原SESSION的sighup，sigint等信号）
os.chdir("/")
os.umask(0)
os.setsid()
#执行第二次fork，防止建立了新SESSION的进程（已成为无终端的会话领导）打开新的终端。
try:
pid = os.fork()
if pid > 0:
sys.exit(0) #second parent out
except OSError, e:
sys.stderr.write("fork #2 failed: (%d) %s]n" %(e.errno,e.strerror))
sys.exit(1)
#进程已经是守护进程了，重定向标准文件描述符
for f in sys.stdout, sys.stderr: f.flush()
si = file(self.stdin, 'r')
so = file(self.stdout,'a+')
se = file(self.stderr,'a+',0)
os.dup2(si.fileno(), sys.stdin.fileno())
os.dup2(so.fileno(), sys.stdout.fileno())
os.dup2(se.fileno(), sys.stderr.fileno())
if __name__ == '__main__':
logfile = sys.argv[1]
d = Daemon('/dev/null',logfile,logfile)
d.daemonize()
while(True):
pass
| [
"oraant777@gmail.com"
] | oraant777@gmail.com |
ae561cf863debd20b40b3f63bd0ef25b4c7e05c6 | ba4cba2f29b926ac9a84c9ba40fc68ea82f95175 | /force-master/feature_utils.py | c3e90e76431ad1427d10237b15f2daf308b89a14 | [
"BSD-3-Clause",
"MIT"
] | permissive | dadatomisin/force_cv | 4e679198b2b0557e8df2bc8a0b4ca6f4c76e5b44 | 2b4e6ffd9b740ca5148a906789a9620b18c5901d | refs/heads/main | 2023-03-30T19:11:03.770791 | 2021-03-24T14:48:26 | 2021-03-24T14:48:26 | 351,116,573 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 6,919 | py | import numpy as np
cm0a = np.asarray([[0.705, 0.02, 0.024, 0.029, 0.09, 0.021, 0.008, 0.032, 0.058, 0.013],
[0.007, 0.925, 0., 0.002, 0.004, 0.008, 0.004, 0.005, 0.026, 0.019],
[0.034, 0.001, 0.542, 0.02, 0.251, 0.102, 0.022, 0.022, 0.006, 0. ],
[0.005, 0.005, 0.012, 0.392, 0.227, 0.308, 0.026, 0.016, 0.009, 0. ],
[0.003, 0.005, 0.003, 0.001, 0.921, 0.016, 0.016, 0.033, 0.002, 0. ],
[0., 0.002, 0.006, 0.022, 0.093, 0.855, 0.003, 0.017, 0.002, 0. ],
[0.001, 0., 0.008, 0.008, 0.08, 0.105, 0.793, 0.002, 0.003, 0. ],
[0.001, 0., 0., 0.003, 0.083, 0.043, 0., 0.868, 0.001, 0.001],
[0.045, 0.021, 0.004, 0.008, 0.013, 0.013, 0.005, 0.01, 0.867, 0.014],
[0.022, 0.095, 0., 0.006, 0.003, 0.042, 0.015, 0.051, 0.024, 0.742]])
cm0b = np.asarray([[0.829, 0.002, 0.016, 0.021, 0.011, 0.001, 0.002, 0.006, 0.012, 0.1 ],
[0.003, 0.819, 0. , 0.003, 0.001, 0. , 0.003, 0. , 0.003, 0.168],
[0.073, 0.001, 0.75 , 0.042, 0.032, 0.028, 0.042, 0.017, 0.002, 0.013],
[0.019, 0.002, 0.049, 0.608, 0.063, 0.087, 0.06 , 0.056, 0.009, 0.047],
[0.017, 0.001, 0.048, 0.009, 0.841, 0.006, 0.025, 0.044, 0. , 0.009],
[0.004, 0. , 0.033, 0.09 , 0.031, 0.705, 0.016, 0.09 , 0.002, 0.029],
[0.005, 0.002, 0.02 , 0.028, 0.029, 0.017, 0.887, 0.002, 0. , 0.01 ],
[0.014, 0.001, 0.018, 0.022, 0.023, 0.011, 0.002, 0.886, 0. , 0.023],
[0.084, 0.014, 0.002, 0.003, 0.002, 0.002, 0.013, 0.001, 0.77 , 0.109],
[0.004, 0.013, 0. , 0.001, 0. , 0. , 0. , 0. , 0.003, 0.979]])
cm1a = np.asarray([[0.731, 0.004, 0.02, 0.001, 0.009, 0., 0.029, 0.006, 0.171, 0.029],
[0.004, 0.714, 0.001, 0., 0.002, 0., 0.039, 0.003, 0.127, 0.11 ],
[0.039, 0., 0.655, 0.003, 0.093, 0.006, 0.156, 0.009, 0.039, 0. ],
[0.025, 0.001, 0.061, 0.427, 0.171, 0.05, 0.168, 0.026, 0.065, 0.006],
[0.007, 0., 0.025, 0.003, 0.902, 0.001, 0.046, 0.013, 0.003, 0. ],
[0.011, 0., 0.071, 0.053, 0.169, 0.496, 0.131, 0.042, 0.023, 0.004],
[0.003, 0., 0.004, 0.002, 0.016, 0., 0.962, 0.003, 0.01, 0. ],
[0.007, 0., 0.026, 0.006, 0.109, 0.008, 0.023, 0.805, 0.013, 0.003],
[0.003, 0., 0.006, 0., 0.003, 0., 0.009, 0., 0.973, 0.006],
[0.005, 0.011, 0.005, 0.002, 0.006, 0., 0.047, 0.002, 0.044, 0.878]])
cm1b = np.asarray([[0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 1., 0.]])
cm2a = np.asarray([[0.849, 0.004, 0.013, 0., 0.009, 0., 0.001, 0.017, 0.105, 0.002],
[0.033, 0.799, 0.002, 0., 0.004, 0., 0.004, 0.007, 0.055, 0.096],
[0.068, 0.002, 0.739, 0.005, 0.073, 0.016, 0.034, 0.039, 0.02, 0.004],
[0.061, 0.01, 0.126, 0.319, 0.08, 0.09, 0.1, 0.131, 0.073, 0.01 ],
[0.01, 0., 0.026, 0.002, 0.838, 0.005, 0.018, 0.091, 0.009, 0.001],
[0.018, 0.005, 0.086, 0.03, 0.036, 0.681, 0.023, 0.103, 0.015, 0.003],
[0.009, 0.003, 0.033, 0.008, 0.028, 0.007, 0.871, 0.018, 0.02, 0.003],
[0.013, 0., 0.011, 0.001, 0.014, 0.009, 0.003, 0.943, 0.003, 0.003],
[0.023, 0.003, 0.005, 0., 0.002, 0., 0., 0.005, 0.96, 0.002],
[0.045, 0.011, 0.004, 0.001, 0.001, 0.001, 0., 0.006, 0.047, 0.884]])
cm2b = np.asarray([[0.763, 0.015, 0.084, 0.074, 0.002, 0.019, 0.002, 0.015, 0.025, 0.001],
[0.009, 0.923, 0.006, 0.02, 0., 0.023, 0.005, 0.001, 0.011, 0.002],
[0.023, 0., 0.72, 0.125, 0.023, 0.084, 0.011, 0.012, 0.001, 0.001],
[0.006, 0., 0.032, 0.775, 0.012, 0.159, 0.009, 0.006, 0.001, 0. ],
[0.017, 0.002, 0.061, 0.178, 0.582, 0.087, 0.024, 0.046, 0.003, 0. ],
[0.002, 0., 0.024, 0.17, 0.008, 0.785, 0.001, 0.01, 0., 0. ],
[0.003, 0.002, 0.034, 0.255, 0.004, 0.042, 0.656, 0.001, 0.002, 0.001],
[0.009, 0., 0.017, 0.08, 0.006, 0.136, 0.001, 0.75, 0.001, 0. ],
[0.108, 0.02, 0.032, 0.07, 0.002, 0.013, 0.002, 0.002, 0.75, 0.001],
[0.064, 0.151, 0.015, 0.074, 0.001, 0.05, 0.007, 0.018, 0.018, 0.602]])
cm3a = np.asarray([[0.942, 0.026, 0.004, 0., 0.002, 0., 0., 0., 0.013, 0.013],
[0.008, 0.973, 0., 0., 0., 0., 0., 0., 0.003, 0.016],
[0.225, 0.014, 0.621, 0.022, 0.039, 0.029, 0.018, 0.013, 0.004, 0.015],
[0.187, 0.067, 0.019, 0.527, 0.047, 0.089, 0.022, 0.021, 0.01 , 0.011],
[0.086, 0.011, 0.017, 0.02, 0.792, 0.014, 0.024, 0.032, 0.001, 0.003],
[0.079, 0.024, 0.016, 0.057, 0.035, 0.753, 0.005, 0.024, 0.002, 0.005],
[0.09, 0.063, 0.026, 0.023, 0.012, 0.014, 0.749, 0.008, 0.003, 0.012],
[0.091, 0.007, 0.005, 0.012, 0.032, 0.022, 0.002, 0.82, 0. , 0.009],
[0.213, 0.068, 0.005, 0.003, 0.006, 0., 0.001, 0.004, 0.679, 0.021],
[0.032, 0.127, 0., 0.001, 0., 0., 0.001, 0., 0.003, 0.836]])
cm3b = np.asarray([[0.732, 0.019, 0.072, 0.009, 0.016, 0.008, 0.007, 0.03, 0.042, 0.065],
[0.003, 0.939, 0.001, 0., 0.001, 0.002, 0.008, 0.003, 0.01 , 0.033],
[0.033, 0.005, 0.717, 0.014, 0.055, 0.055, 0.055, 0.051, 0.003, 0.012],
[0.008, 0.011, 0.036, 0.398, 0.069, 0.284, 0.08 , 0.082, 0.01 , 0.022],
[0.006, 0.001, 0.023, 0.008, 0.812, 0.019, 0.018, 0.106, 0.003, 0.004],
[0.004, 0.002, 0.031, 0.024, 0.031, 0.804, 0.01, 0.087, 0. , 0.007],
[0.002, 0.003, 0.033, 0.006, 0.025, 0.032, 0.867, 0.024, 0.001, 0.007],
[0.003, 0., 0.012, 0.01, 0.017, 0.035, 0.001, 0.914, 0. , 0.008],
[0.048, 0.027, 0.011, 0.004, 0.004, 0.003, 0.01, 0.014, 0.84 , 0.039],
[0.003, 0.058, 0.001, 0.005, 0., 0.005, 0.001, 0.013, 0.01 , 0.904]])
s0a = 0.761
s0b = 0.
s1a = 0.7543
s1b = 0.1
s2a = 0.7883
s2b = 0.7306
s3a = 0.7692
s3b = 0.7927
import pdb; pdb.set_trace() | [
"noreply@github.com"
] | dadatomisin.noreply@github.com |
64b4ef84a18ddd9f2bc43240c84053e62ea65453 | b244948b59a27b162d066298dddb804941a07298 | /pekja/utils.py | d982e1feba79b2df8c38438463b6d8b2030ee933 | [] | no_license | sry309/pekja | 6f1160bb998de845ff059ab5d83029338091fcdc | 1534753df393cc4396f1fb1bff95ec13588e4a49 | refs/heads/master | 2021-05-20T09:00:19.685982 | 2020-03-21T03:05:56 | 2020-03-21T03:05:56 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 3,770 | py | import os
from html import escape
from platform import system
from crontab import CronTab
from django.core.mail import EmailMessage
from django.template.loader import render_to_string
from django.contrib.auth import get_user_model
from pekja.settings import DEFAULT_FROM_EMAIL
from pekja.settings import DATA_DIRS
from pekja.settings import CRON_USER
from task.models import Task
def get_input_file_path(obj):
return os.path.join(DATA_DIRS, 'input-{}.txt'.format(obj.id))
def get_output_file_path(obj):
return os.path.join(DATA_DIRS, 'output-{}.txt'.format(obj.id))
def get_mail_report_dispatch_file_path():
return os.path.join(DATA_DIRS, 'mail_report_dispatch.txt')
def get_task_cron_comment(obj):
return 'task-{}-pekja'.format(obj.id)
def get_batch_task_cron_comment(obj):
return 'batch-task-{}-pekja'.format(obj.id)
def get_mail_report_cron_comment():
return '#send-mail-report-pekja'
def get_windows_cron_file_path():
cron_file_path = os.path.join(DATA_DIRS, 'windows_crontab.txt')
if not os.path.exists(cron_file_path):
with open(cron_file_path, 'w') as f:
pass
return cron_file_path
def get_task_by_id(task_id):
"""
根据ID返回Task
:param task_id:
:return:
"""
try:
task = Task.objects.get(id=task_id)
except Task.DoesNotExist:
return None
else:
return task
def get_user_emails():
"""
获取所有用户的邮箱地址
:return:
"""
user = get_user_model()
emails = [email for email in user.objects.values_list('email', flat=True) if email != '']
return emails
def send_mail_to_users(subject, title, message):
"""
给所有用户发送邮件
:param subject:
:param title:
:param message:
:return:
"""
emails = get_user_emails()
if len(emails) > 0:
msg_html = render_to_string('email.html', {'title': title, 'content': message})
msg = EmailMessage(subject=subject, body=msg_html, from_email=DEFAULT_FROM_EMAIL, to=emails)
msg.content_subtype = 'html'
return msg.send()
def rowspan_html_table(headers, input_dict):
"""
将输入的字典转换为HTML表格
:param headers:
:param input_dict:
:return:
"""
table = '<table border="1" cellspacing="0"><thead><tr>'
for header in headers:
table += '<th style="text-align: center;">' + escape(header) + '</th>'
table += '</tr></thead>'
for key in input_dict:
for index, sub_key in enumerate(input_dict[key]):
row = '<tr>'
if index == 0:
row += '<td rowspan="{}" style="text-align: center;">'.format(len(input_dict[key])) + key + '</td>'
row += '<td style="text-align: center;">' + escape(sub_key) + '</td>'
row += '<td style="text-align: center;">' + escape(str(input_dict[key][sub_key])) + '</td>'
row += '</tr>'
table += row
table += '</table>'
return table
def open_crontab():
"""
打开crontab
:return:
"""
if system() == 'Windows':
cron = CronTab(tabfile=get_windows_cron_file_path()) # 仅用于调试
else:
cron = CronTab(user=CRON_USER)
return cron
def human_size(size):
def str_of_size(integer, remainder, level):
if integer >= 1024:
remainder = integer % 1024
integer //= 1024
level += 1
return str_of_size(integer, remainder, level)
else:
return integer, remainder, level
units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB']
integer, remainder, level = str_of_size(size, 0, 0)
if level + 1 > len(units):
level = -1
return '{}.{:>02d} {}'.format(integer, remainder, units[level])
| [
"me@werner.wiki"
] | me@werner.wiki |
bafc73e9e2d92ab11157f9796b307fe297a062c4 | ab1dfc351cfb3928674f8ed9d938f1b131f74838 | /chatApi/app/Event/Msg.py | 7e141efa80c9c1926df480db0b86d148625c7648 | [
"Apache-2.0"
] | permissive | huaSoftware/chat | 1222fc620a70a4d8f67ae7f42ac04fcb7bed9e59 | e9c18455bb317495af83bb1caebfeccd78bd9187 | refs/heads/master | 2022-12-08T21:19:35.138378 | 2020-10-23T12:38:35 | 2020-10-23T12:38:35 | 192,302,764 | 16 | 6 | Apache-2.0 | 2022-12-08T06:35:35 | 2019-06-17T08:06:55 | JavaScript | UTF-8 | Python | false | false | 321 | py | '''
@Author: hua
@Date: 2019-12-03 14:44:23
@description:
@LastEditors: hua
@LastEditTime: 2019-12-03 15:02:10
'''
from app.Models.Msg import Msg
from sqlalchemy import event
import time
@event.listens_for(Msg, "before_insert")
def msg_before_insert(mapper, connection, target):
target.created_at = int(time.time()) | [
"584425439@qq.com"
] | 584425439@qq.com |
f888a09eee26ae4a58a6c72db2c9cf77907251c5 | 1d5c6b57d034f30ce24ba500a4d20b191f16ac43 | /31.py | cdf40ff0743b49a411e2497ca4bf683178480b0d | [] | no_license | Meghashrestha/assignment-python | 8d30ebcafc2e11040020ee1150c7f86afdd1504a | 150240ddaa0e166544e1b1539a652a5a1c0f229d | refs/heads/master | 2022-11-09T06:40:30.169973 | 2020-06-28T11:39:19 | 2020-06-28T11:39:19 | 275,571,936 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 392 | py | # 31. Write a Python program to iterate over dictionaries using for loops.
my_dict = dict()
n= int(input("enter the number of item in the dictionary you want to input : "))
for i in range(0,n):
key = input("Enter the key: ")
value = input("Enter the value: ")
my_dict[key] = value
print(my_dict)
for key, value in my_dict.items():
print(key,'dictionary item is',my_dict[key])
| [
"meghashrestha30@gmail.com"
] | meghashrestha30@gmail.com |
768f6de70068718e53d853ecba3b2732ba5da6cd | bd752709dd5f45ad53081d0670c44a17ae675624 | /test_melanoma.py | 05a1087e58e66d3d4aa8654df3fd551dc7ad005e | [
"Apache-2.0"
] | permissive | sameer0805/WebDatabase | 955877c8db6e7ae59c69476db6ed3f41d66868c6 | 4a5d0c5361ecb67b3b971786eb8c0c8b13d944d1 | refs/heads/master | 2021-05-07T00:43:04.796633 | 2017-12-14T15:14:44 | 2017-12-14T15:14:44 | 110,165,376 | 0 | 0 | null | 2017-12-14T15:14:45 | 2017-11-09T20:56:14 | Python | UTF-8 | Python | false | false | 3,383 | py | from main import determine_filepath, validate, analyze_image
from flask import Flask, request, jsonify
from flask_cors import CORS
from time import gmtime, strftime
import base64
import re
import numpy as np
from setup_db import User, write_file
from melanomapredictions import predict
import sys
sys.path.insert(0, '/notebooks/react-learning/')
sys.path.insert(0, '/notebooks/react-learning/melcolor.py')
from meldiameter import contour
from melcolor import colorplot
def test_filetype():
"""
This method tests that file types are correctly identified and that a file that is not
one of the commonly accepted types (.jpg, .png, .bmp) will be rejected.
"""
decoded_jpg = "data:image/jpeg;base64," + \
base64.b64encode(open("test_images/test_jpgfile.jpeg",
'rb').read())
decoded_png = "data:image/png;base64" + \
base64.b64encode(open("test_images/test_pngfile.png",
'rb').read())
decoded_bmp = "data:image/bmp;base64" + \
base64.b64encode(open("test_images/test_bmpfile.bmp",
'rb').read())
decoded_wrong = "data:image/gif;base64" + \
base64.b64encode(open
("test_images/test_file_incorrect.gif",
'rb').read())
filepath_jpg, filepath_without_end_jpg, file_ending_jpg = \
determine_filepath(decoded_jpg)
filepath_png, filepath_without_end_png, file_ending_png = \
determine_filepath(decoded_png)
filepath_bmp, filepath_without_end_bmp, file_ending_bmp = \
determine_filepath(decoded_bmp)
filepath_gif, filepath_without_end_gif, file_ending_gif = \
determine_filepath(decoded_wrong)
assert file_ending_jpg == ".jpg"
assert file_ending_png == ".png"
assert file_ending_bmp == ".bmp"
assert file_ending_gif == ""
def test_validate():
"""
This test tests the prediction of an expected image and ensures that
its prediction probabilities are as expected.
"""
image_string = "data:image/jpeg;base64," + base64.b64encode(
open("test_images/Melanoma.jpg", 'rb').read())
filepath = "test_images/Melanoma.jpg"
filepath_without_ending = "Melanoma"
file_ending = ".jpg"
results = analyze_image(filepath, filepath_without_ending,
file_ending, image_string)
probabilities = results["probabilities"]
assert probabilities[0] == 0.732
assert probabilities[1] == 0.268
def test_null_result():
"""
Thie test uses an incorrect file type and verifies that the correct
error message is returned to the web server.
"""
decoded_wrong = "data:image/gif;base64" + \
base64.b64encode(open(
"test_images/test_file_incorrect.gif", 'rb').read())
filepath_gif, filepath_without_end_gif, file_ending_gif = \
determine_filepath(decoded_wrong)
results = analyze_image(filepath_gif, filepath_without_end_gif,
file_ending_gif, decoded_wrong)
assert results["labels"] == "Error: Incorrect file type uploaded"
probabilities = results["probabilities"]
assert probabilities[0] == "Error"
assert probabilities[1] == "Incorrect file type"
| [
"alice@Alices-MacBook-Pro.local"
] | alice@Alices-MacBook-Pro.local |
f384ea5bcd062e35c370ad8dfe0502fb86f1fe16 | 39de8c1d3dc87361d3d0048c02a50d6aacd0769d | /user/models.py | 7c54a1ee170797157a003af80cfab558b20ff770 | [] | no_license | yeamin21/ubayy | 9890360fd5aca869e9101e67c6fd3bcfc5244629 | d2c071bcc5df0d74917b95f8566c50178bad5425 | refs/heads/main | 2023-06-15T18:29:46.052379 | 2021-07-05T21:55:52 | 2021-07-05T21:55:52 | 370,625,462 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 375 | py | from django.db import models
from django.contrib.auth.models import AbstractUser, BaseUserManager
class User(AbstractUser):
email = models.EmailField(max_length=250, unique=True)
username = models.CharField(null=True, blank=True, max_length=20)
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = ['username']
def __str__(self):
return f'{self.email}'
| [
"yeamin21@outlook.com"
] | yeamin21@outlook.com |
77889153b32bd9f59bf9e86346e2260d3c052596 | 2121a7072abc9b239949a2efc798e67d184b1b52 | /test/test_del_group.py | b032fc5316d8aa15c65055204b5d8aa657294d08 | [] | no_license | el-labs/python_training | d5a11013bd3060bb9ed9c81b10d379eec6f9d7d5 | 7ac7170071e38f8df827af88e7e4555a6d644f18 | refs/heads/master | 2022-11-06T15:09:52.180707 | 2020-07-02T14:47:47 | 2020-07-02T14:47:47 | 259,080,463 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 486 | py | from model.group import Group
from random import randrange
def test_del_some_group(app):
if app.group.count() == 0:
app.group.create_contact(Group(name="", header="", footer=""))
old_groups = app.group.get_group_list()
index = randrange(len(old_groups))
app.group.delete_group_by_index(index)
assert len(old_groups) - 1 == app.group.count()
new_groups = app.group.get_group_list()
old_groups[index:index+1] = []
assert old_groups == new_groups
| [
"a.kosmatykh@hotmail.com"
] | a.kosmatykh@hotmail.com |
1258f388ef158ca0387123f39fb49abe83baedb8 | bc01e1d158e7d8f28451a7e108afb8ec4cb7d5d4 | /sage/src/sage/interfaces/giac.py | a144910f149d64f01f0c0f4ac473b19e74454a0b | [] | no_license | bopopescu/geosci | 28792bda1ec1f06e23ba8dcb313769b98f793dad | 0d9eacbf74e2acffefde93e39f8bcbec745cdaba | refs/heads/master | 2021-09-22T17:47:20.194233 | 2018-09-12T22:19:36 | 2018-09-12T22:19:36 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 36,943 | py | r"""
Interface to Giac
(adapted by F. Han from William Stein and Gregg Musiker maple's interface)
You must have the optional Giac interpreter installed
and available as the command ``giac`` in your PATH in
order to use this interface. You need a giac version
supporting "giac --sage" ( roughly after 0.9.1 ). In this case you do not have
to install any optional Sage packages. If giac is not already installed, you can
download binaries or sources or spkg (follow the sources link) from the homepage:
Homepage <http://www-fourier.ujf-grenoble.fr/~parisse/giac.html>
Type ``giac.[tab]`` for a list of all the functions
available from your Giac install. Type
``giac.[tab]?`` for Giac's help about a given
function. Type ``giac(...)`` to create a new Giac
object, and ``giac.eval(...)`` to run a string using
Giac (and get the result back as a string).
If the giac spkg is installed, you should find the full html documentation there::
$SAGE_LOCAL/share/giac/doc/en/cascmd_local/index.html
EXAMPLES::
sage: giac('3 * 5') # optional - giac
15
sage: giac.eval('ifactor(2005)') # optional - giac
'5*401'
sage: giac.ifactor(2005) # optional - giac
2005
sage: l=giac.ifactors(2005) ; l; l[2] # optional - giac
[5,1,401,1]
401
sage: giac.fsolve('x^2=cos(x)+4', 'x','0..5') # optional - giac
[1.9140206190...
sage: giac.factor('x^5 - y^5') # optional - giac
(x-y)*(x^4+x^3*y+x^2*y^2+x*y^3+y^4)
sage: R.<x,y>=QQ[];f=(x+y)^5;f2=giac(f);(f-f2).normal() #optional - giac
0
sage: x,y=giac('x,y'); giac.int(y/(cos(2*x)+cos(x)),x) #random; optional - giac
y*2*((-(tan(x/2)))/6+(-2*1/6/sqrt(3))*ln(abs(6*tan(x/2)-2*sqrt(3))/abs(6*tan(x/2)+2*sqrt(3))))
If the string "error" (case insensitive) occurs in the output of
anything from Giac, a RuntimeError exception is raised.
Tutorial
--------
AUTHORS:
- Gregg Musiker (2006-02-02): initial version.
(adapted to giac by F.Han)
This tutorial is based on the Maple Tutorial for number theory from
http://www.math.mun.ca/~drideout/m3370/numtheory.html.
There are several ways to use the Giac Interface in Sage. We will
discuss two of those ways in this tutorial.
#. If you have a giac expression such as
::
factor( (x^5-1));
We can write that in sage as
::
sage: giac('factor(x^5-1)') # optional - giac
(x-1)*(x^4+x^3+x^2+x+1)
Notice, there is no need to use a semicolon.
#. Since Sage is written in Python, we can also import giac
commands and write our scripts in a pythonic way. For example,
``factor()`` is a giac command, so we can also factor
in Sage using
::
sage: giac('(x^5-1)').factor() # optional - giac
(x-1)*(x^4+x^3+x^2+x+1)
where ``expression.command()`` means the same thing as
``command(expression)`` in Giac. We will use this
second type of syntax whenever possible, resorting to the first
when needed.
::
sage: giac('(x^12-1)/(x-1)').normal() # optional - giac
x^11+x^10+x^9+x^8+x^7+x^6+x^5+x^4+x^3+x^2+x+1
The normal command will reduce a rational function to the
lowest terms. In giac, simplify is slower than normal because it
tries more sophisticated simplifications (ex algebraic extensions)
The factor command will factor a polynomial with
rational coefficients into irreducible factors over the ring of
integers (if your default configuration of giac (cf .xcasrc) has not
allowed square roots). So for example,
::
sage: giac('(x^12-1)').factor( ) # optional - giac
(x-1)*(x+1)*(x^2+1)*(x^2-x+1)*(x^2+x+1)*(x^4-x^2+1)
::
sage: giac('(x^28-1)').factor( ) # optional - giac
(x-1)*(x+1)*(x^2+1)*(x^6-x^5+x^4-x^3+x^2-x+1)*(x^6+x^5+x^4+x^3+x^2+x+1)*(x^12-x^10+x^8-x^6+x^4-x^2+1)
Another important feature of giac is its online help. We can
access this through sage as well. After reading the description of
the command, you can press q to immediately get back to your
original prompt.
Incidentally you can always get into a giac console by the
command.
::
sage: giac.console() # not tested
sage: !giac # not tested
Note that the above two commands are slightly different, and the
first is preferred.
For example, for help on the giac command factors, we type ::
sage: giac.help('factors') # not tested
::
sage: alpha = giac((1+sqrt(5))/2) # optional - giac
sage: beta = giac(1-sqrt(5))/2 # optional - giac
sage: f19 = alpha^19 - beta^19/sqrt(5) # optional - giac
sage: f19 # optional - giac
(sqrt(5)/2+1/2)^19-((-sqrt(5)+1)/2)^19/sqrt(5)
sage: (f19-(5778*sqrt(5)+33825)/5).normal() # optional - giac
0
Let's say we want to write a giac program now that squares a
number if it is positive and cubes it if it is negative. In giac,
that would look like
::
mysqcu := proc(x)
if x > 0 then x^2;
else x^3; fi;
end;
In Sage, we write
::
sage: mysqcu = giac('proc(x) if x > 0 then x^2 else x^3 fi end') # optional - giac
sage: mysqcu(5) # optional - giac
25
sage: mysqcu(-5) # optional - giac
-125
More complicated programs should be put in a separate file and
loaded.
"""
#############################################################################
# Copyright (C) 2005 William Stein <wstein@gmail.com>
#
# Distributed under the terms of the GNU General Public License (GPL)
#
# http://www.gnu.org/licenses/
#############################################################################
from __future__ import print_function
import os
from sage.interfaces.expect import Expect, ExpectElement, ExpectFunction, FunctionElement, gc_disabled
from sage.interfaces.tab_completion import ExtraTabCompletion
import pexpect
from sage.env import DOT_SAGE
from sage.misc.pager import pager
COMMANDS_CACHE = '%s/giac_commandlist_cache.sobj'%DOT_SAGE
class Giac(Expect):
r"""
Interface to the Giac interpreter.
You must have the optional Giac interpreter installed and available as the command ``giac`` in your PATH in order to use this interface. Try the command: print(giac._install_hints()) for more informations on giac installation.
Type ``giac.[tab]`` for a list of all the functions available from your Giac install.
Type ``giac.[tab]?`` for Giac's help about a given function.
Type ``giac(...)`` to create a new Giac object.
Full html documentation for giac is avaible from your giac installation at ``$PREFIX``/share/giac/doc/en/cascmd_en/index.html
EXAMPLES:
Any Giac instruction can be evaluated as a string by the giac command. You can access the giac functions by adding the ``giac.`` prefix to the usual Giac name.
::
sage: l=giac('normal((y+sqrt(2))^4)'); l # optional - giac
y^4+4*sqrt(2)*y^3+12*y^2+8*sqrt(2)*y+4
sage: f=giac('(u,v)->{ if (u<v){ [u,v] } else { [v,u] }}');f(1,2),f(3,1) # optional - giac
([1,2], [1,3])
The output of the giac command is a Giac object, and it can be used for another giac command.
::
sage: l.factors() #optional - giac
[y+sqrt(2),4]
sage: giac('(x^12-1)').factor( ) # optional - giac
(x-1)*(x+1)*(x^2+1)*(x^2-x+1)*(x^2+x+1)*(x^4-x^2+1)
sage: giac('assume(y>0)'); giac('y^2=3').solve('y') #optional - giac
y
...[sqrt(3)]
You can create some Giac elements and avoid many quotes like this:
::
sage: x,y,z=giac('x,y,z');type(y) # optional - giac
<class 'sage.interfaces.giac.GiacElement'>
sage: I1=(1/(cos(2*y)+cos(y))).integral(y,0,pi/4).simplify() #optional - giac
sage: (I1-((-2*ln((sqrt(3)-3*tan(1/8*pi))/(sqrt(3)+3*tan(1/8*pi)))*sqrt(3)-3*tan(1/8*pi))/9)).normal() # optional - giac
0
sage: ((y+z*sqrt(5))*(y-sqrt(5)*z)).normal() # optional - giac
y^2-5*z^2
Polynomials or elements of SR can be evaluated directly by the giac interface.
::
sage: R.<a,b>=QQ[];f=(2+a+b);p=giac.gcd(f^3+5*f^5,f^2+f^5);p;R(p); #optional - giac
a^2+2*a*b+4*a+b^2+4*b+4
a^2 + 2*a*b + b^2 + 4*a + 4*b + 4
Variable names in python and giac are independant.
::
sage: a=sqrt(2);giac('Digits:=30;a:=5');a,giac('a'),giac(a),giac(a).evalf() # optional - giac
30
(sqrt(2), 5, sqrt(2), 1.41421356237309504880168872421)
"""
def __init__(self, maxread=None, script_subdirectory=None, server=None, server_tmpdir=None, logfile=None):
"""
Create an instance of the Giac interpreter.
EXAMPLES::
sage: giac == loads(dumps(giac)) # optional - giac
True
"""
Expect.__init__(self,
name = 'giac',
prompt = '[0-9]*>> ',
command = "giac --sage",
init_code= ['maple_mode(0);I:=i;'], # coercion could be broken in maple_mode
script_subdirectory = script_subdirectory,
restart_on_ctrlc = False, server = server,
server_tmpdir = server_tmpdir,
verbose_start = False,
logfile = logfile,
eval_using_file_cutoff=1000)
def _function_class(self):
"""
EXAMPLES::
sage: giac._function_class() # optional - giac
<class 'sage.interfaces.giac.GiacFunction'>
::
sage: type(giac.diff) # optional - giac
<class 'sage.interfaces.giac.GiacFunction'>
"""
return GiacFunction
def _keyboard_interrupt(self):
"""
The pexepect interface for giac has a very poor support of keyboard interruptions.
"""
print("Interrupting %s..." % self)
self._expect.sendline(chr(3)) # send ctrl-c
self._expect.expect(self._prompt)
# self._expect.expect(self._prompt)
raise RuntimeError("Ctrl-c pressed while running %s"%self)
def __reduce__(self):
"""
EXAMPLES::
sage: giac.__reduce__()
(<function reduce_load_Giac at 0x...>, ())
sage: f, args = _
sage: f(*args)
Giac
"""
return reduce_load_Giac, tuple([])
def _read_in_file_command(self, filename):
r"""
Returns the string used to read filename into Giac.
EXAMPLES::
sage: giac._read_in_file_command('test') # optional - giac
'read "test"'
::
sage: filename = tmp_filename() # optional - giac
sage: f = open(filename,'w') # optional - giac
sage: f.write('xx := 22;\n') # optional - giac
sage: f.close() # optional - giac
sage: giac.read(filename) # optional - giac
sage: giac.get('xx').strip() # optional - giac
'22'
"""
return 'read "%s"'%filename
def _quit_string(self):
"""
EXAMPLES::
sage: giac._quit_string() # optional - giac
'@d'
::
sage: m = Giac() # optional - giac
sage: a = m(2) # optional - giac
sage: m.is_running() # optional - giac
True
sage: m.quit() # optional - giac
sage: m.is_running() # optional - giac
False
"""
return '@d'
def _install_hints(self):
"""
Hints for installing Giac on your computer.
EXAMPLES::
sage: print(giac._install_hints())
In order...
"""
return r"""
In order to use the Giac interface you need to have Giac installed
and have a program called "giac" in your PATH. You need a giac version
supporting "giac --sage" ( roughly after 0.9.1 of march 2011). Some giac
instructions and the help's langage depend of you LANG variable. To obtain
inline help for giac commands, you also need to have the program "cas_help"
in your PATH.
If giac is not already installed, you can download binaries or sources
or a spkg ( for the spkg follow the sources link) from the homepage:
Homepage http://www-fourier.ujf-grenoble.fr/~parisse/giac.html
Full html documentation for giac is avaible from your giac installation at:
``$PREFIX``/share/giac/doc/en/cascmd_en/index.html
If you got giac from the spkg then ``$PREFIX`` is ``$SAGE_LOCAL``
"""
def expect(self):
"""
Returns the pexpect object for this Giac session.
EXAMPLES::
sage: m = Giac() # optional - giac
sage: m.expect() is None # optional - giac
True
sage: m._start() # optional - giac
sage: m.expect() # optional - giac
Giac with PID ... running .../giac --sage
sage: m.quit() # optional - giac
"""
return self._expect
def console(self):
"""
Spawn a new Giac command-line session.
EXAMPLES::
sage: giac_console() # not tested - giac
...
Homepage http://www-fourier.ujf-grenoble.fr/~parisse/giac.html
Released under the GPL license 3.0 or above
See http://www.gnu.org for license details
-------------------------------------------------
Press CTRL and D simultaneously to finish session
Type ?commandname for help
0>>
"""
giac_console()
def completions(self, s):
"""
Return all commands that complete the command starting with the
string s.
EXAMPLES::
sage: c = giac.completions('cas') # optional - giac
sage: 'cas_setup' in c # optional - giac
True
"""
if self._expect is None:
self._start()
E = self._expect
E.sendline('%s%s%s'%(s,chr(63),chr(13)))
t = E.timeout
E.timeout=0.3 # since some things have no completion
try:
E.expect('----')
except pexpect.TIMEOUT:
E.timeout = t
return []
E.timeout = t
v = E.before
E.expect(self._prompt)
E.expect(self._prompt)
return v.split()[1:]
def _commands(self):
"""
Return list of all commands defined in Giac.
EXAMPLES::
sage: c = giac._commands() # optional - giac
sage: len(c) > 100 # optional - giac
True
sage: 'Psi' in c # optional - giac
True
"""
try:
v = sum([self.completions(chr(65+n)) for n in range(26)], []) + \
sum([self.completions(chr(97+n)) for n in range(26)], [])
except RuntimeError:
print("\n" * 3)
print("*" * 70)
print("WARNING: You do not have a working version of Giac installed!")
print("*" * 70)
v = []
v.sort()
return v
def _tab_completion(self, verbose=True, use_disk_cache=True):
"""
Returns a list of all the commands defined in Giac and optionally
(per default) store them to disk.
EXAMPLES::
sage: c = giac._tab_completion(use_disk_cache=False, verbose=False) # optional - giac
sage: len(c) > 100 # optional - giac
True
sage: 'factors' in c # optional - giac
True
"""
try:
return self.__tab_completion
except AttributeError:
import sage.misc.persist
if use_disk_cache:
try:
self.__tab_completion = sage.misc.persist.load(COMMANDS_CACHE)
return self.__tab_completion
except IOError:
pass
if verbose:
print("\nBuilding Giac command completion list (this takes")
print("a few seconds only the first time you do it).")
print("To force rebuild later, delete %s." % COMMANDS_CACHE)
v = self._commands()
self.__tab_completion = v
if len(v) > 200:
# Giac is actually installed.
sage.misc.persist.save(v, COMMANDS_CACHE)
return v
def cputime(self, t=None):
r"""
Returns the amount of CPU time that the Giac session has used. If
``t`` is not None, then it returns the difference
between the current CPU time and ``t``.
EXAMPLES::
sage: t = giac.cputime() # optional - giac
sage: t # random; optional - giac
0.02
sage: x = giac('x') # optional - giac
sage: giac.diff(x^2, x) # optional - giac
2*x
sage: giac.cputime(t) # random; optional - giac
0.0
"""
if t is None:
return float(self('time()'))
else:
return float(self('time() - %s'%float(t)))
def _eval_line(self, line, allow_use_file=True, wait_for_prompt=True, restart_if_needed=False):
"""
EXAMPLES::
sage: giac._eval_line('2+2') # optional - giac
'4'
sage: A=matrix([range(280)]) # optional - giac
sage: GA=giac(A) # optional - giac
"""
with gc_disabled():
z = Expect._eval_line(self, line, allow_use_file=allow_use_file,
wait_for_prompt=wait_for_prompt)
if z.lower().find("error") != -1:
raise RuntimeError("An error occurred running a Giac command:\nINPUT:\n%s\nOUTPUT:\n%s"%(line, z))
return z
def eval(self, code, strip=True, **kwds):
r"""
Send the code x to the Giac interpreter.
Remark: To enable multi-lines codes in the notebook magic mode: ``%giac``,
the ``\n`` are removed before sending the code to giac.
INPUT:
- code -- str
- strip -- Default is True and removes ``\n``
EXAMPLES::
sage: giac.eval("2+2;\n3") #optional - giac
'4,3'
sage: giac.eval("2+2;\n3",False) # optional - giac
'4\n3'
sage: s='g(x):={\nx+1;\nx+2;\n}' # optional - giac
sage: giac(s) # optional - giac
(x)->{
x+1;
x+2;
}
sage: giac.g(5) # optional - giac
7
"""
#we remove \n to enable multiline code in the notebook magic mode %giac
if strip:
code = code.replace("\n","").strip()
ans = Expect.eval(self, code, strip=strip, **kwds).strip()
return ans
def set(self, var, value):
"""
Set the variable var to the given value.
EXAMPLES::
sage: giac.set('xx', '2') # optional - giac
sage: giac.get('xx') # optional - giac
'2'
"""
cmd = '%s:=%s:;'%(var,value) #if giac is not in maple mode ( maple_mode(0))
out = self.eval(cmd)
if out.find("error") != -1:
raise TypeError("Error executing code in Giac\nCODE:\n\t%s\nGiac ERROR:\n\t%s"%(cmd, out))
def get(self, var):
"""
Get the value of the variable var.
EXAMPLES::
sage: giac.set('xx', '2') # optional - giac
sage: giac.get('xx') # optional - giac
'2'
"""
s = self.eval('%s'%var)
return s
def _object_class(self):
"""
Returns the class of GiacElements.
EXAMPLES::
sage: giac._object_class()
<class 'sage.interfaces.giac.GiacElement'>
::
sage: m = giac(2) # optional - giac
sage: type(m) # optional - giac
<class 'sage.interfaces.giac.GiacElement'>
"""
return GiacElement
def _function_element_class(self):
"""
Returns the GiacFunctionElement class.
EXAMPLES::
sage: giac._function_element_class()
<class 'sage.interfaces.giac.GiacFunctionElement'>
::
sage: two = giac(2) # optional - giac
sage: type(two.gcd) # optional - giac
<class 'sage.interfaces.giac.GiacFunctionElement'>
"""
return GiacFunctionElement
def _equality_symbol(self):
"""
Returns the symbol used for equality testing in Giac.
EXAMPLES::
sage: giac._equality_symbol() # optional - giac
'=='
sage: giac(2) == giac(2) # optional - giac
True
"""
return '=='
def _true_symbol(self):
"""
Returns the symbol used for truth in Giac.
EXAMPLES::
sage: giac._true_symbol()
'1'
::
sage: giac(2) == giac(2) # optional - giac
True
"""
return '1'
def _assign_symbol(self):
"""
Returns the symbol used for assignment in Giac.
EXAMPLES::
sage: giac._assign_symbol()
':='
"""
return ":="
def _help(self, str):
r"""
Returns the Giac help on ``str``.
EXAMPLES::
sage: giac._help('gcd') # not tested ; output may vary (LANG)
"...gcd - greatest common divisor of polynomials...
"""
return os.popen('cas_help %s'%str).read()
# return os.popen('echo "?%s" | giac'%str).read()
def help(self, str):
"""
Display Giac help about str. This is the same as typing "?str" in
the Giac console.
INPUT:
- ``str`` - a string to search for in the giac help
system
EXAMPLES::
sage: giac.help('Psi') # not tested - depends of giac and $LANG
Psi(a,n)=nth-derivative of the function DiGamma (=ln@Gamma) at point a (Psi(a,0)=Psi(a))...
"""
pager()(self._help(str))
def clear(self, var):
"""
Clear the variable named var.
EXAMPLES::
sage: giac.set('xx', '2') # optional - giac
sage: giac.get('xx') # optional - giac
'2'
sage: giac.clear('xx') # optional - giac
sage: giac.get('xx') # optional - giac
'xx'
"""
self.eval('purge(%s)'%var)
def version(self):
"""
Wrapper for giac's version().
EXAMPLES::
sage: giac.version() # optional - giac
"giac...
"""
return giac('version()')
class GiacFunction(ExpectFunction):
def _sage_doc_(self):
"""
Returns the Giac help for this function. This gets called when
doing "?" on self.
EXAMPLES::
sage: giac.gcd._sage_doc_() # not tested ; output may vary LANG
"gcd - greatest common divisor of polynomials...
"""
M = self._parent
return M._help(self._name)
class GiacFunctionElement(FunctionElement):
def _sage_doc_(self):
"""
Returns the Giac help for this function. This gets called when
doing "?" on self.
EXAMPLES::
sage: two = giac(2) # optional - giac
sage: two.gcd._sage_doc_() # not tested; output may vary LANG
"...gcd - greatest common divisor of polynomials...
"""
return self._obj.parent()._help(self._name)
class GiacElement(ExpectElement):
def __float__(self):
"""
Returns a floating point version of self.
EXAMPLES::
sage: float(giac(1/2)) # optional - giac
0.5
sage: type(_) # optional - giac
<type 'float'>
"""
return float(giac.eval('evalf(%s)' % self.name()))
def unapply(self, var):
"""
Creates a Giac function in the given arguments from a Giac symbol.
EXAMPLES::
sage: f=giac('y^3+1+t') # optional - giac
sage: g=(f.unapply('y,t')) # optional - giac
sage: g # optional - giac
(y,t)->y^3+1+t
sage: g(1,2) # optional - giac
4
"""
return giac('unapply(%s,%s)'%(self,var))
def __hash__(self):
"""
Returns a integer representing the hash of self.
These examples are optional, and require Giac to be installed. You
don't need to install any Sage packages for this.
EXAMPLES::
sage: m = giac('x^2+y^2') # optional - giac
sage: hash(m) # random; optional - giac
4614285348919569149
"""
return hash(giac.eval('string(%s);'%self.name()))
def __cmp__(self, other):
"""
Compare equality between self and other, using giac.
These examples are optional, and require Giac to be installed. You
don't need to install any Sage packages for this.
EXAMPLES::
sage: a = giac(5) # optional - giac
sage: b = giac(5) # optional - giac
sage: a == b # optional - giac
True
sage: a == 5 # optional - giac
True
::
sage: c = giac(3) # optional - giac
sage: a == c # optional - giac
False
sage: a < c # optional - giac
False
sage: a < 6 # optional - giac
True
sage: c <= a # optional - giac
True
::
TESTS::
sage: x = var('x') # optional - giac
sage: t = giac((x+1)^2) # optional - giac
sage: u = giac(x^2+2*x+1) # optional - giac
sage: u == t # optional - giac
False
"""
P = self.parent()
if P.eval("evalb(%s %s %s)"%(self.name(), P._equality_symbol(),
other.name())) == P._true_symbol():
return 0
# (to be tested with giac). Maple does not allow comparing objects of different types and
# it raises an error in this case.
# We catch the error, and return True for <
try:
if P.eval("evalb(%s %s %s)"%(self.name(), P._lessthan_symbol(), other.name())) == P._true_symbol():
return -1
except RuntimeError as e:
msg = str(e)
if 'is not valid' in msg and 'to < or <=' in msg:
if (hash(str(self)) < hash(str(other))):
return -1
else:
return 1
else:
raise RuntimeError(e)
if P.eval("evalb(%s %s %s)"%(self.name(), P._greaterthan_symbol(), other.name())) == P._true_symbol():
return 1
# everything is supposed to be comparable in Python, so we define
# the comparison thus when no comparable in interfaced system.
if (hash(self) < hash(other)):
return -1
else:
return 1
def _tab_completion(self):
"""
EXAMPLES::
sage: a = giac(2) # optional - giac
sage: 'sin' in a._tab_completion() # optional - giac
True
"""
return self.parent()._tab_completion()
def __len__(self):
"""
EXAMPLES::
sage: len(giac([1,2,3])) # optional - giac
3
"""
return int(self.size())
def __iter__(self):
"""
EXAMPLES::
sage: l = giac([1,2,3]) # optional - giac
sage: list(iter(l)) # optional - giac
[1, 2, 3]
"""
for i in range(len(self)): # zero-indexed if giac is maple_mode(0)
yield self[i]
def __del__(self):
"""
Note that clearing object is pointless since it wastes time.
(Ex: otherwise doing a=0 after a = (giac('x+y+z')^40).normal() is very slow )
EXAMPLES::
sage: a = giac(2) # optional - giac
sage: a.__del__() # optional - giac
sage: a # optional - giac
2
sage: del a # optional - giac
sage: a
Traceback (most recent call last):
...
NameError: name 'a' is not defined
"""
return
def __repr__(self):
"""
Return a string representation of self.
These examples are optional, and require Giac to be installed. You
don't need to install any Sage packages for this.
EXAMPLES::
sage: x = var('x')
sage: giac(x) # optional - giac
x
sage: giac(5) # optional - giac
5
sage: M = matrix(QQ,2,range(4)) # optional - giac
sage: giac(M) # optional - giac
[[0,1],[2,3]]
"""
self._check_valid()
return self.parent().get(self._name)
def _latex_(self):
r"""
You can output Giac expressions in latex.
EXAMPLES::
sage: print(latex(giac('(x^4 - y)/(y^2-3*x)'))) # optional - giac
"\frac{(x^{4}-y)}{(y^{2}-3\cdot x)}"
"""
return self.parent().eval('latex(%s)'%self.name())
def _matrix_(self, R):
r"""
Return matrix over the (Sage) ring R determined by self, where self
should be a Giac matrix.
Warning: It is slow, don't convert big matrices.
EXAMPLES::
sage: R.<x,y>=QQ[] # optional - giac
sage: M=giac('matrix(4,4,(k,l)->(x^k-y^l))'); M # optional - giac
matrix[[0,1-y,1-y^2,1-y^3],[x-1,x-y,x-y^2,x-y^3],[x^2-1,x^2-y,x^2-y^2,x^2-y^3],[x^3-1,x^3-y,x^3-y^2,x^3-y^3]]
sage: M.eigenvals() # random; optional - giac
0,0,(x^3+x^2+x-y^3-y^2-y+sqrt(x^6+2*x^5+3*x^4-14*x^3*y^3+2*x^3*y^2+2*x^3*y+6*x^3+2*x^2*y^3-14*x^2*y^2+2*x^2*y+5*x^2+2*x*y^3+2*x*y^2-14*x*y+4*x+y^6+2*y^5+3*y^4+6*y^3+5*y^2+4*y-12))/2,(x^3+x^2+x-y^3-y^2-y-sqrt(x^6+2*x^5+3*x^4-14*x^3*y^3+2*x^3*y^2+2*x^3*y+6*x^3+2*x^2*y^3-14*x^2*y^2+2*x^2*y+5*x^2+2*x*y^3+2*x*y^2-14*x*y+4*x+y^6+2*y^5+3*y^4+6*y^3+5*y^2+4*y-12))/2
sage: Z=matrix(R,M);Z # optional - giac
[ 0 -y + 1 -y^2 + 1 -y^3 + 1]
[ x - 1 x - y -y^2 + x -y^3 + x]
[ x^2 - 1 x^2 - y x^2 - y^2 -y^3 + x^2]
[ x^3 - 1 x^3 - y x^3 - y^2 x^3 - y^3]
sage: parent(Z) # optional - giac
Full MatrixSpace of 4 by 4 dense matrices over Multivariate Polynomial Ring in x, y over Rational Field
"""
v = self.dim()
n = int(v[0])
m = int(v[1])
from sage.matrix.matrix_space import MatrixSpace
M = MatrixSpace(R, n, m)
entries = [[R(self[r, c]) for c in range(m)] for r in range(n)]
return M(entries)
def _sage_(self):
r"""
Convert a giac expression back to a Sage expression.
This currently does not implement a parser for the Giac output language,
therefore only very simple expressions will convert successfully.
Warning: List conversion is slow.
EXAMPLE::
sage: m = giac('x^2 + 5*y') # optional - giac
sage: m.sage() # optional - giac
x^2 + 5*y
::
sage: m = giac('sin(2*sqrt(1-x^2)) * (1 - cos(1/x))^2') # optional - giac
sage: m.trigexpand().sage() # optional - giac
2*cos(sqrt(-x^2 + 1))*cos(1/x)^2*sin(sqrt(-x^2 + 1)) - 4*cos(sqrt(-x^2 + 1))*cos(1/x)*sin(sqrt(-x^2 + 1)) + 2*cos(sqrt(-x^2 + 1))*sin(sqrt(-x^2 + 1))
"""
result = repr(self)
if str(self.type()) != 'DOM_LIST' :
try:
from sage.symbolic.all import SR
return SR(result)
except Exception:
raise NotImplementedError("Unable to parse Giac output: %s" % result)
else:
return [entry.sage() for entry in self]
def integral(self, var='x', min=None, max=None):
r"""
Return the integral of self with respect to the variable x.
INPUT:
- ``var`` - variable
- ``min`` - default: None
- ``max`` - default: None
Returns the definite integral if xmin is not None, otherwise
returns an indefinite integral.
EXAMPLES::
sage: y=giac('y');f=(sin(2*y)/y).integral(y).simplify(); f # optional - giac
Si(2*y)
sage: f.diff(y).simplify() # optional - giac
sin(2*y)/y
::
sage: f = giac('exp(x^2)').integral('x',0,1) ; f # optional - giac
1.46265174...
sage: x,y=giac('x'),giac('y');integrate(cos(x+y),'x=0..pi').simplify() # optional - giac
-2*sin(y)
"""
if min is None:
return giac('int(%s,%s)'%(self.name(),var))
else:
if max is None:
raise ValueError("neither or both of min/max must be specified.")
return giac('int(%s,%s,%s,%s)'%(self.name(),var,giac(min),giac(max)))
integrate=integral
def sum(self, var, min=None, max=None):
r"""
Return the sum of self with respect to the variable x.
INPUT:
- ``var`` - variable
- ``min`` - default: None
- ``max`` - default: None
Returns the definite integral if xmin is not None, otherwise
returns an indefinite integral.
EXAMPLES::
sage: giac('1/(1+k^2)').sum('k',-oo,+infinity).simplify() # optional - giac
(pi*exp(pi)^2+pi)/(exp(pi)^2-1)
"""
if min is None:
return giac('sum(%s,%s)'%(self.name(),var))
else:
if max is None:
raise ValueError("neither or both of min/max must be specified.")
return giac('sum(%s,%s,%s,%s)'%(self.name(),var,giac(min),giac(max)))
# An instance
giac = Giac()
def reduce_load_Giac():
"""
Returns the giac object created in sage.interfaces.giac.
EXAMPLES::
sage: from sage.interfaces.giac import reduce_load_Giac
sage: reduce_load_Giac()
Giac
"""
return giac
def giac_console():
"""
Spawn a new Giac command-line session.
EXAMPLES::
sage: giac.console() # not tested - giac
...
Homepage http://www-fourier.ujf-grenoble.fr/~parisse/giac.html
Released under the GPL license 3.0 or above
See http://www.gnu.org for license details
-------------------------------------------------
Press CTRL and D simultaneously to finish session
Type ?commandname for help
"""
from sage.repl.rich_output.display_manager import get_display_manager
if not get_display_manager().is_in_terminal():
raise RuntimeError('Can use the console only in the terminal. Try %%giac magics instead.')
os.system('giac')
def __doctest_cleanup():
"""
EXAMPLES::
sage: from sage.interfaces.giac import __doctest_cleanup
sage: m = giac(2) # optional - giac
sage: giac.is_running() # optional - giac
True
sage: __doctest_cleanup()
sage: giac.is_running()
False
"""
import sage.interfaces.quit
sage.interfaces.quit.expect_quitall()
| [
"valber@HPC"
] | valber@HPC |
6fa3076b90f0fc78f2ed7de867f7b3f81c9ab896 | 00144932bbac7819ed5cd7e721082ac2b9b4103f | /algorithms/stack/stack_parenthesis_check.py | e84e9ca42903524d5b1bdba3fbf5a67103d31393 | [] | no_license | danielsada/100daysofalgorithms | c6b81614c4db74d66a864cb827d4d572dd10f73c | 8020d9fa09b0ac04ea5564a84191cc21163cb55c | refs/heads/master | 2022-10-22T11:34:57.243317 | 2022-10-03T09:58:17 | 2022-10-03T09:58:17 | 121,158,462 | 14 | 7 | null | null | null | null | UTF-8 | Python | false | false | 1,218 | py | __author__ = "Daniel Sada"
__license__ = "MIT Licence"
__email__ = "hello@danielsada.tech"
class StackParenthesisCheck:
""""
Implement a stack that checks if match of square brackets,
tags and parenthesis match their level.
Accepts <> () [] {}
"""
def __init__(self, string):
self.string = string
self.stack = []
self.isSyntaxCorrect = self.checkParenthesis(string)
def checkParenthesis(self, string) -> bool:
for char in string:
if char == '{' or char == '[' or char == '<' or char == '(':
self.stack.append(char)
if char == '}':
if len(self.stack) == 0 or self.stack.pop() != '{':
return False
if char == ']':
if len(self.stack) == 0 or self.stack.pop() != '[':
return False
if char == '>':
if len(self.stack) == 0 or self.stack.pop() != '<':
return False
if char == ')':
if len(self.stack) == 0 or self.stack.pop() != '(':
return False
if len(self.stack) > 0:
return False
else:
return True
| [
"danielsadac@gmail.com"
] | danielsadac@gmail.com |
4a56709e97ff5145a635e78961eacacc40399a84 | 300e4d9672b5e3c25f4a06055c29bbd7f2235203 | /M5_Forecasting/pgm/eda.py | 61722dda40d571a647063c275d817e58557b55eb | [] | no_license | skn27/kaggle | 8bcabf0bccf8311ab7b0790fa21420c5221a961d | 7d5537c499992f6652c20b0f5f22c7a40eda6ab3 | refs/heads/master | 2020-07-27T23:05:34.960367 | 2020-04-19T06:39:52 | 2020-04-19T06:39:52 | 209,239,714 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 507 | py | # %%
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
sns.set()
import os
if not os.getcwd() == '/Users/soki/Documents/kaggle/M5_Forecasting/':
os.chdir('/Users/soki/Documents/kaggle/M5_Forecasting/')
# %%
calender = pd.read_csv('data/calendar.csv')
sales_train_val = pd.read_csv('data/sales_train_validation.csv')
sample_sub = pd.read_csv('data/sample_submission.csv')
sell_prices = pd.read_csv('data/sell_prices.csv')
# %%
sales_train_val.head()
# %%
| [
"c.lv.pg.tit@gmail.com"
] | c.lv.pg.tit@gmail.com |
f41facc51474c9c8b75bdf9eb8cbff2452c343ac | f409f0b5be2bccdc76041a308b28964b00565c2b | /untitled/urls.py | 93f59be44255ae6fefe35db65a6c61417a4d3618 | [] | no_license | yingliufengpeng/demo_django_blog | b9df1e9176ffd66fe9cf6b8fcbad34092aaa8c53 | 27b3e88ebc7e84f8b4d2a8844abd35104bec2bdb | refs/heads/master | 2021-01-17T07:50:52.081607 | 2017-06-26T18:48:56 | 2017-06-26T18:48:56 | 95,317,444 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,704 | py | """untitled URL Configuration
The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/1.8/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: url(r'^$', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: url(r'^$', Home.as_view(), name='home')
Including another URLconf
1. Add an import: from blog import urls as blog_urls
2. Add a URL to urlpatterns: url(r'^blog/', include(blog_urls))
"""
from django.conf.urls import include, url
from django.contrib import admin
from django.conf import settings
from django.views import static
from demo import views
urlpatterns = [
url(r'^admin/', include(admin.site.urls)),
url(r"^uploads/(?P<path>.*)$", static.serve, {"document_root": settings.MEDIA_ROOT}),
url(r"^login/", views.login, name='login'),
url(r"^logout/", views.logout, name='logout'),
url(r"^register/", views.register, name='register'),
url(r"^index/", views.index, name='index'),
url(r"^home/", views.home, name='home'),
url(r"^article/", views.article, name='article'),
url(r"^add_article/", views.add_article, name='add_article'),
url(r"^upload_img/", views.upload_img, name='upload_img'),
url(r"^article_ajax_add/", views.article_ajax_add, name='article_ajax_add'),
url(r"^modify_article/", views.modify_article, name='modify_article'),
url(r"^article_ajax_modify/", views.article_ajax_modify, name='article_ajax_modify'),
url(r"^article_ajax_delete/", views.article_ajax_delete, name='article_ajax_delete'),
]
| [
"root@localhost.localdomain"
] | root@localhost.localdomain |
31a9912f4a72df65b04385107f6527ff09b4e795 | 183024afcefdadb6dbb9f1633ef3d07f1e13021c | /utils/arrayFunctions.py | 3be02cb2180366c1d353aadd74434ea23704e4f1 | [] | no_license | agar98/fastest_search | cf9b78994fbba13a960ae6aa90f14017a7531df5 | 4152b1fca548527461415f68f5b56f9e6ca84f1f | refs/heads/main | 2023-01-06T11:18:26.157989 | 2020-11-07T12:21:39 | 2020-11-07T12:21:39 | 310,539,024 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 702 | py | import random
from utils.logs import print_log
from utils.performanceCalculator import performance
@performance
def generate_array(size, max_number):
print_log('info', 'Generating array')
arr = random.sample(range(1, max_number), size)
return arr
def quick_sort(array):
if array == []:
return []
else:
pivot = array[0]
lesser = quick_sort([x for x in array[1:] if x < pivot])
greater = quick_sort([x for x in array[1:] if x >= pivot])
return lesser + [pivot] + greater
@performance
def sort_array(array):
print_log('info', 'Sorting array...')
arr = quick_sort(array)
print_log('success', 'Array sorted!')
return arr
| [
"aditya.agar98@gmail.com"
] | aditya.agar98@gmail.com |
d91562b560e5544252d65cea772f0354892a9d9c | 49995ddbd8f9714e8766687e1c90432a95201e92 | /test/python/sample/stdlib/test_tarfile.py | 099db2ad879d6532fcc5bc7b3be23b7a8599b408 | [
"MIT"
] | permissive | esoma/woosh | 73e07a0e5d99066a44c9ad7ec80da8e7a81c5be3 | 4cd58eb93c69c48040ff1e25159e48def54c3111 | refs/heads/master | 2023-04-07T03:20:27.661162 | 2021-03-26T00:11:16 | 2021-03-26T00:11:16 | 319,500,780 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 797,304 | py |
# this file was generated using test/python/sample/generate.py
# python
import io
import pathlib
# pytest
import pytest
# woosh
import woosh
def tokenize_file_like(source):
return list(woosh.tokenize(io.BytesIO(source)))
def tokenize_bytes(source):
return list(woosh.tokenize(source))
SAMPLE_DIR = pathlib.Path(__file__).parent.absolute() / '../../' / '../../' / 'sample'
@pytest.mark.parametrize('tokenize', [tokenize_file_like, tokenize_bytes])
def test(tokenize):
with open(SAMPLE_DIR / 'stdlib/tarfile.py', 'rb') as f:
tokens = tokenize(f.read())
for token, expected in zip(tokens, EXPECTED):
assert token == expected
EXPECTED = [
woosh.Token(woosh.ENCODING, 'utf-8', 1, 0, 1, 0),
woosh.Token(woosh.COMMENT, '#!/usr/bin/env python3', 1, 0, 1, 22),
woosh.Token(woosh.COMMENT, '#-------------------------------------------------------------------', 2, 0, 2, 68),
woosh.Token(woosh.COMMENT, '# tarfile.py', 3, 0, 3, 12),
woosh.Token(woosh.COMMENT, '#-------------------------------------------------------------------', 4, 0, 4, 68),
woosh.Token(woosh.COMMENT, '# Copyright (C) 2002 Lars Gustaebel <lars@gustaebel.de>', 5, 0, 5, 55),
woosh.Token(woosh.COMMENT, '# All rights reserved.', 6, 0, 6, 22),
woosh.Token(woosh.COMMENT, '#', 7, 0, 7, 1),
woosh.Token(woosh.COMMENT, '# Permission is hereby granted, free of charge, to any person', 8, 0, 8, 67),
woosh.Token(woosh.COMMENT, '# obtaining a copy of this software and associated documentation', 9, 0, 9, 67),
woosh.Token(woosh.COMMENT, '# files (the "Software"), to deal in the Software without', 10, 0, 10, 67),
woosh.Token(woosh.COMMENT, '# restriction, including without limitation the rights to use,', 11, 0, 11, 67),
woosh.Token(woosh.COMMENT, '# copy, modify, merge, publish, distribute, sublicense, and/or sell', 12, 0, 12, 67),
woosh.Token(woosh.COMMENT, '# copies of the Software, and to permit persons to whom the', 13, 0, 13, 67),
woosh.Token(woosh.COMMENT, '# Software is furnished to do so, subject to the following', 14, 0, 14, 67),
woosh.Token(woosh.COMMENT, '# conditions:', 15, 0, 15, 13),
woosh.Token(woosh.COMMENT, '#', 16, 0, 16, 1),
woosh.Token(woosh.COMMENT, '# The above copyright notice and this permission notice shall be', 17, 0, 17, 67),
woosh.Token(woosh.COMMENT, '# included in all copies or substantial portions of the Software.', 18, 0, 18, 65),
woosh.Token(woosh.COMMENT, '#', 19, 0, 19, 1),
woosh.Token(woosh.COMMENT, '# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,', 20, 0, 20, 67),
woosh.Token(woosh.COMMENT, '# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES', 21, 0, 21, 67),
woosh.Token(woosh.COMMENT, '# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND', 22, 0, 22, 67),
woosh.Token(woosh.COMMENT, '# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT', 23, 0, 23, 67),
woosh.Token(woosh.COMMENT, '# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,', 24, 0, 24, 67),
woosh.Token(woosh.COMMENT, '# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING', 25, 0, 25, 67),
woosh.Token(woosh.COMMENT, '# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR', 26, 0, 26, 63),
woosh.Token(woosh.COMMENT, '# OTHER DEALINGS IN THE SOFTWARE.', 27, 0, 27, 33),
woosh.Token(woosh.COMMENT, '#', 28, 0, 28, 1),
woosh.Token(woosh.STRING, '"""Read from and write to tar format archives.\r\n"""', 29, 0, 30, 3),
woosh.Token(woosh.NEWLINE, '\r\n', 30, 3, 31, 0),
woosh.Token(woosh.NAME, 'version', 32, 0, 32, 7),
woosh.Token(woosh.OP, '=', 32, 12, 32, 13),
woosh.Token(woosh.STRING, '"0.9.0"', 32, 14, 32, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 32, 21, 33, 0),
woosh.Token(woosh.NAME, '__author__', 33, 0, 33, 10),
woosh.Token(woosh.OP, '=', 33, 12, 33, 13),
woosh.Token(woosh.STRING, '"Lars Gust\\u00e4bel (lars@gustaebel.de)"', 33, 14, 33, 54),
woosh.Token(woosh.NEWLINE, '\r\n', 33, 54, 34, 0),
woosh.Token(woosh.NAME, '__credits__', 34, 0, 34, 11),
woosh.Token(woosh.OP, '=', 34, 12, 34, 13),
woosh.Token(woosh.STRING, '"Gustavo Niemeyer, Niels Gust\\u00e4bel, Richard Townsend."', 34, 14, 34, 72),
woosh.Token(woosh.NEWLINE, '\r\n', 34, 72, 35, 0),
woosh.Token(woosh.COMMENT, '#---------', 36, 0, 36, 10),
woosh.Token(woosh.COMMENT, '# Imports', 37, 0, 37, 9),
woosh.Token(woosh.COMMENT, '#---------', 38, 0, 38, 10),
woosh.Token(woosh.NAME, 'from', 39, 0, 39, 4),
woosh.Token(woosh.NAME, 'builtins', 39, 5, 39, 13),
woosh.Token(woosh.NAME, 'import', 39, 14, 39, 20),
woosh.Token(woosh.NAME, 'open', 39, 21, 39, 25),
woosh.Token(woosh.NAME, 'as', 39, 26, 39, 28),
woosh.Token(woosh.NAME, 'bltn_open', 39, 29, 39, 38),
woosh.Token(woosh.NEWLINE, '\r\n', 39, 38, 40, 0),
woosh.Token(woosh.NAME, 'import', 40, 0, 40, 6),
woosh.Token(woosh.NAME, 'sys', 40, 7, 40, 10),
woosh.Token(woosh.NEWLINE, '\r\n', 40, 10, 41, 0),
woosh.Token(woosh.NAME, 'import', 41, 0, 41, 6),
woosh.Token(woosh.NAME, 'os', 41, 7, 41, 9),
woosh.Token(woosh.NEWLINE, '\r\n', 41, 9, 42, 0),
woosh.Token(woosh.NAME, 'import', 42, 0, 42, 6),
woosh.Token(woosh.NAME, 'io', 42, 7, 42, 9),
woosh.Token(woosh.NEWLINE, '\r\n', 42, 9, 43, 0),
woosh.Token(woosh.NAME, 'import', 43, 0, 43, 6),
woosh.Token(woosh.NAME, 'shutil', 43, 7, 43, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 43, 13, 44, 0),
woosh.Token(woosh.NAME, 'import', 44, 0, 44, 6),
woosh.Token(woosh.NAME, 'stat', 44, 7, 44, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 44, 11, 45, 0),
woosh.Token(woosh.NAME, 'import', 45, 0, 45, 6),
woosh.Token(woosh.NAME, 'time', 45, 7, 45, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 45, 11, 46, 0),
woosh.Token(woosh.NAME, 'import', 46, 0, 46, 6),
woosh.Token(woosh.NAME, 'struct', 46, 7, 46, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 46, 13, 47, 0),
woosh.Token(woosh.NAME, 'import', 47, 0, 47, 6),
woosh.Token(woosh.NAME, 'copy', 47, 7, 47, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 47, 11, 48, 0),
woosh.Token(woosh.NAME, 'import', 48, 0, 48, 6),
woosh.Token(woosh.NAME, 're', 48, 7, 48, 9),
woosh.Token(woosh.NEWLINE, '\r\n', 48, 9, 49, 0),
woosh.Token(woosh.NAME, 'try', 50, 0, 50, 3),
woosh.Token(woosh.OP, ':', 50, 3, 50, 4),
woosh.Token(woosh.NEWLINE, '\r\n', 50, 4, 51, 0),
woosh.Token(woosh.INDENT, ' ', 51, 0, 51, 4),
woosh.Token(woosh.NAME, 'import', 51, 4, 51, 10),
woosh.Token(woosh.NAME, 'pwd', 51, 11, 51, 14),
woosh.Token(woosh.NEWLINE, '\r\n', 51, 14, 52, 0),
woosh.Token(woosh.DEDENT, '', 52, 0, 52, 0),
woosh.Token(woosh.NAME, 'except', 52, 0, 52, 6),
woosh.Token(woosh.NAME, 'ImportError', 52, 7, 52, 18),
woosh.Token(woosh.OP, ':', 52, 18, 52, 19),
woosh.Token(woosh.NEWLINE, '\r\n', 52, 19, 53, 0),
woosh.Token(woosh.INDENT, ' ', 53, 0, 53, 4),
woosh.Token(woosh.NAME, 'pwd', 53, 4, 53, 7),
woosh.Token(woosh.OP, '=', 53, 8, 53, 9),
woosh.Token(woosh.NAME, 'None', 53, 10, 53, 14),
woosh.Token(woosh.NEWLINE, '\r\n', 53, 14, 54, 0),
woosh.Token(woosh.DEDENT, '', 54, 0, 54, 0),
woosh.Token(woosh.NAME, 'try', 54, 0, 54, 3),
woosh.Token(woosh.OP, ':', 54, 3, 54, 4),
woosh.Token(woosh.NEWLINE, '\r\n', 54, 4, 55, 0),
woosh.Token(woosh.INDENT, ' ', 55, 0, 55, 4),
woosh.Token(woosh.NAME, 'import', 55, 4, 55, 10),
woosh.Token(woosh.NAME, 'grp', 55, 11, 55, 14),
woosh.Token(woosh.NEWLINE, '\r\n', 55, 14, 56, 0),
woosh.Token(woosh.DEDENT, '', 56, 0, 56, 0),
woosh.Token(woosh.NAME, 'except', 56, 0, 56, 6),
woosh.Token(woosh.NAME, 'ImportError', 56, 7, 56, 18),
woosh.Token(woosh.OP, ':', 56, 18, 56, 19),
woosh.Token(woosh.NEWLINE, '\r\n', 56, 19, 57, 0),
woosh.Token(woosh.INDENT, ' ', 57, 0, 57, 4),
woosh.Token(woosh.NAME, 'grp', 57, 4, 57, 7),
woosh.Token(woosh.OP, '=', 57, 8, 57, 9),
woosh.Token(woosh.NAME, 'None', 57, 10, 57, 14),
woosh.Token(woosh.NEWLINE, '\r\n', 57, 14, 58, 0),
woosh.Token(woosh.COMMENT, '# os.symlink on Windows prior to 6.0 raises NotImplementedError', 59, 0, 59, 63),
woosh.Token(woosh.DEDENT, '', 60, 0, 60, 0),
woosh.Token(woosh.NAME, 'symlink_exception', 60, 0, 60, 17),
woosh.Token(woosh.OP, '=', 60, 18, 60, 19),
woosh.Token(woosh.OP, '(', 60, 20, 60, 21),
woosh.Token(woosh.NAME, 'AttributeError', 60, 21, 60, 35),
woosh.Token(woosh.OP, ',', 60, 35, 60, 36),
woosh.Token(woosh.NAME, 'NotImplementedError', 60, 37, 60, 56),
woosh.Token(woosh.OP, ')', 60, 56, 60, 57),
woosh.Token(woosh.NEWLINE, '\r\n', 60, 57, 61, 0),
woosh.Token(woosh.NAME, 'try', 61, 0, 61, 3),
woosh.Token(woosh.OP, ':', 61, 3, 61, 4),
woosh.Token(woosh.NEWLINE, '\r\n', 61, 4, 62, 0),
woosh.Token(woosh.COMMENT, '# OSError (winerror=1314) will be raised if the caller does not hold the', 62, 4, 62, 76),
woosh.Token(woosh.COMMENT, '# SeCreateSymbolicLinkPrivilege privilege', 63, 4, 63, 45),
woosh.Token(woosh.INDENT, ' ', 64, 0, 64, 4),
woosh.Token(woosh.NAME, 'symlink_exception', 64, 4, 64, 21),
woosh.Token(woosh.OP, '+=', 64, 22, 64, 24),
woosh.Token(woosh.OP, '(', 64, 25, 64, 26),
woosh.Token(woosh.NAME, 'OSError', 64, 26, 64, 33),
woosh.Token(woosh.OP, ',', 64, 33, 64, 34),
woosh.Token(woosh.OP, ')', 64, 34, 64, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 64, 35, 65, 0),
woosh.Token(woosh.DEDENT, '', 65, 0, 65, 0),
woosh.Token(woosh.NAME, 'except', 65, 0, 65, 6),
woosh.Token(woosh.NAME, 'NameError', 65, 7, 65, 16),
woosh.Token(woosh.OP, ':', 65, 16, 65, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 65, 17, 66, 0),
woosh.Token(woosh.INDENT, ' ', 66, 0, 66, 4),
woosh.Token(woosh.NAME, 'pass', 66, 4, 66, 8),
woosh.Token(woosh.NEWLINE, '\r\n', 66, 8, 67, 0),
woosh.Token(woosh.COMMENT, '# from tarfile import *', 68, 0, 68, 23),
woosh.Token(woosh.DEDENT, '', 69, 0, 69, 0),
woosh.Token(woosh.NAME, '__all__', 69, 0, 69, 7),
woosh.Token(woosh.OP, '=', 69, 8, 69, 9),
woosh.Token(woosh.OP, '[', 69, 10, 69, 11),
woosh.Token(woosh.STRING, '"TarFile"', 69, 11, 69, 20),
woosh.Token(woosh.OP, ',', 69, 20, 69, 21),
woosh.Token(woosh.STRING, '"TarInfo"', 69, 22, 69, 31),
woosh.Token(woosh.OP, ',', 69, 31, 69, 32),
woosh.Token(woosh.STRING, '"is_tarfile"', 69, 33, 69, 45),
woosh.Token(woosh.OP, ',', 69, 45, 69, 46),
woosh.Token(woosh.STRING, '"TarError"', 69, 47, 69, 57),
woosh.Token(woosh.OP, ',', 69, 57, 69, 58),
woosh.Token(woosh.STRING, '"ReadError"', 69, 59, 69, 70),
woosh.Token(woosh.OP, ',', 69, 70, 69, 71),
woosh.Token(woosh.STRING, '"CompressionError"', 70, 11, 70, 29),
woosh.Token(woosh.OP, ',', 70, 29, 70, 30),
woosh.Token(woosh.STRING, '"StreamError"', 70, 31, 70, 44),
woosh.Token(woosh.OP, ',', 70, 44, 70, 45),
woosh.Token(woosh.STRING, '"ExtractError"', 70, 46, 70, 60),
woosh.Token(woosh.OP, ',', 70, 60, 70, 61),
woosh.Token(woosh.STRING, '"HeaderError"', 70, 62, 70, 75),
woosh.Token(woosh.OP, ',', 70, 75, 70, 76),
woosh.Token(woosh.STRING, '"ENCODING"', 71, 11, 71, 21),
woosh.Token(woosh.OP, ',', 71, 21, 71, 22),
woosh.Token(woosh.STRING, '"USTAR_FORMAT"', 71, 23, 71, 37),
woosh.Token(woosh.OP, ',', 71, 37, 71, 38),
woosh.Token(woosh.STRING, '"GNU_FORMAT"', 71, 39, 71, 51),
woosh.Token(woosh.OP, ',', 71, 51, 71, 52),
woosh.Token(woosh.STRING, '"PAX_FORMAT"', 71, 53, 71, 65),
woosh.Token(woosh.OP, ',', 71, 65, 71, 66),
woosh.Token(woosh.STRING, '"DEFAULT_FORMAT"', 72, 11, 72, 27),
woosh.Token(woosh.OP, ',', 72, 27, 72, 28),
woosh.Token(woosh.STRING, '"open"', 72, 29, 72, 35),
woosh.Token(woosh.OP, ']', 72, 35, 72, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 72, 36, 73, 0),
woosh.Token(woosh.COMMENT, '#---------------------------------------------------------', 74, 0, 74, 58),
woosh.Token(woosh.COMMENT, '# tar constants', 75, 0, 75, 15),
woosh.Token(woosh.COMMENT, '#---------------------------------------------------------', 76, 0, 76, 58),
woosh.Token(woosh.NAME, 'NUL', 77, 0, 77, 3),
woosh.Token(woosh.OP, '=', 77, 4, 77, 5),
woosh.Token(woosh.STRING, 'b"\\0"', 77, 6, 77, 11),
woosh.Token(woosh.COMMENT, '# the null character', 77, 32, 77, 52),
woosh.Token(woosh.NEWLINE, '\r\n', 77, 52, 78, 0),
woosh.Token(woosh.NAME, 'BLOCKSIZE', 78, 0, 78, 9),
woosh.Token(woosh.OP, '=', 78, 10, 78, 11),
woosh.Token(woosh.NUMBER, '512', 78, 12, 78, 15),
woosh.Token(woosh.COMMENT, '# length of processing blocks', 78, 32, 78, 61),
woosh.Token(woosh.NEWLINE, '\r\n', 78, 61, 79, 0),
woosh.Token(woosh.NAME, 'RECORDSIZE', 79, 0, 79, 10),
woosh.Token(woosh.OP, '=', 79, 11, 79, 12),
woosh.Token(woosh.NAME, 'BLOCKSIZE', 79, 13, 79, 22),
woosh.Token(woosh.OP, '*', 79, 23, 79, 24),
woosh.Token(woosh.NUMBER, '20', 79, 25, 79, 27),
woosh.Token(woosh.COMMENT, '# length of records', 79, 32, 79, 51),
woosh.Token(woosh.NEWLINE, '\r\n', 79, 51, 80, 0),
woosh.Token(woosh.NAME, 'GNU_MAGIC', 80, 0, 80, 9),
woosh.Token(woosh.OP, '=', 80, 10, 80, 11),
woosh.Token(woosh.STRING, 'b"ustar \\0"', 80, 12, 80, 24),
woosh.Token(woosh.COMMENT, '# magic gnu tar string', 80, 32, 80, 54),
woosh.Token(woosh.NEWLINE, '\r\n', 80, 54, 81, 0),
woosh.Token(woosh.NAME, 'POSIX_MAGIC', 81, 0, 81, 11),
woosh.Token(woosh.OP, '=', 81, 12, 81, 13),
woosh.Token(woosh.STRING, 'b"ustar\\x0000"', 81, 14, 81, 28),
woosh.Token(woosh.COMMENT, '# magic posix tar string', 81, 32, 81, 56),
woosh.Token(woosh.NEWLINE, '\r\n', 81, 56, 82, 0),
woosh.Token(woosh.NAME, 'LENGTH_NAME', 83, 0, 83, 11),
woosh.Token(woosh.OP, '=', 83, 12, 83, 13),
woosh.Token(woosh.NUMBER, '100', 83, 14, 83, 17),
woosh.Token(woosh.COMMENT, '# maximum length of a filename', 83, 32, 83, 62),
woosh.Token(woosh.NEWLINE, '\r\n', 83, 62, 84, 0),
woosh.Token(woosh.NAME, 'LENGTH_LINK', 84, 0, 84, 11),
woosh.Token(woosh.OP, '=', 84, 12, 84, 13),
woosh.Token(woosh.NUMBER, '100', 84, 14, 84, 17),
woosh.Token(woosh.COMMENT, '# maximum length of a linkname', 84, 32, 84, 62),
woosh.Token(woosh.NEWLINE, '\r\n', 84, 62, 85, 0),
woosh.Token(woosh.NAME, 'LENGTH_PREFIX', 85, 0, 85, 13),
woosh.Token(woosh.OP, '=', 85, 14, 85, 15),
woosh.Token(woosh.NUMBER, '155', 85, 16, 85, 19),
woosh.Token(woosh.COMMENT, '# maximum length of the prefix field', 85, 32, 85, 68),
woosh.Token(woosh.NEWLINE, '\r\n', 85, 68, 86, 0),
woosh.Token(woosh.NAME, 'REGTYPE', 87, 0, 87, 7),
woosh.Token(woosh.OP, '=', 87, 8, 87, 9),
woosh.Token(woosh.STRING, 'b"0"', 87, 10, 87, 14),
woosh.Token(woosh.COMMENT, '# regular file', 87, 32, 87, 46),
woosh.Token(woosh.NEWLINE, '\r\n', 87, 46, 88, 0),
woosh.Token(woosh.NAME, 'AREGTYPE', 88, 0, 88, 8),
woosh.Token(woosh.OP, '=', 88, 9, 88, 10),
woosh.Token(woosh.STRING, 'b"\\0"', 88, 11, 88, 16),
woosh.Token(woosh.COMMENT, '# regular file', 88, 32, 88, 46),
woosh.Token(woosh.NEWLINE, '\r\n', 88, 46, 89, 0),
woosh.Token(woosh.NAME, 'LNKTYPE', 89, 0, 89, 7),
woosh.Token(woosh.OP, '=', 89, 8, 89, 9),
woosh.Token(woosh.STRING, 'b"1"', 89, 10, 89, 14),
woosh.Token(woosh.COMMENT, '# link (inside tarfile)', 89, 32, 89, 55),
woosh.Token(woosh.NEWLINE, '\r\n', 89, 55, 90, 0),
woosh.Token(woosh.NAME, 'SYMTYPE', 90, 0, 90, 7),
woosh.Token(woosh.OP, '=', 90, 8, 90, 9),
woosh.Token(woosh.STRING, 'b"2"', 90, 10, 90, 14),
woosh.Token(woosh.COMMENT, '# symbolic link', 90, 32, 90, 47),
woosh.Token(woosh.NEWLINE, '\r\n', 90, 47, 91, 0),
woosh.Token(woosh.NAME, 'CHRTYPE', 91, 0, 91, 7),
woosh.Token(woosh.OP, '=', 91, 8, 91, 9),
woosh.Token(woosh.STRING, 'b"3"', 91, 10, 91, 14),
woosh.Token(woosh.COMMENT, '# character special device', 91, 32, 91, 58),
woosh.Token(woosh.NEWLINE, '\r\n', 91, 58, 92, 0),
woosh.Token(woosh.NAME, 'BLKTYPE', 92, 0, 92, 7),
woosh.Token(woosh.OP, '=', 92, 8, 92, 9),
woosh.Token(woosh.STRING, 'b"4"', 92, 10, 92, 14),
woosh.Token(woosh.COMMENT, '# block special device', 92, 32, 92, 54),
woosh.Token(woosh.NEWLINE, '\r\n', 92, 54, 93, 0),
woosh.Token(woosh.NAME, 'DIRTYPE', 93, 0, 93, 7),
woosh.Token(woosh.OP, '=', 93, 8, 93, 9),
woosh.Token(woosh.STRING, 'b"5"', 93, 10, 93, 14),
woosh.Token(woosh.COMMENT, '# directory', 93, 32, 93, 43),
woosh.Token(woosh.NEWLINE, '\r\n', 93, 43, 94, 0),
woosh.Token(woosh.NAME, 'FIFOTYPE', 94, 0, 94, 8),
woosh.Token(woosh.OP, '=', 94, 9, 94, 10),
woosh.Token(woosh.STRING, 'b"6"', 94, 11, 94, 15),
woosh.Token(woosh.COMMENT, '# fifo special device', 94, 32, 94, 53),
woosh.Token(woosh.NEWLINE, '\r\n', 94, 53, 95, 0),
woosh.Token(woosh.NAME, 'CONTTYPE', 95, 0, 95, 8),
woosh.Token(woosh.OP, '=', 95, 9, 95, 10),
woosh.Token(woosh.STRING, 'b"7"', 95, 11, 95, 15),
woosh.Token(woosh.COMMENT, '# contiguous file', 95, 32, 95, 49),
woosh.Token(woosh.NEWLINE, '\r\n', 95, 49, 96, 0),
woosh.Token(woosh.NAME, 'GNUTYPE_LONGNAME', 97, 0, 97, 16),
woosh.Token(woosh.OP, '=', 97, 17, 97, 18),
woosh.Token(woosh.STRING, 'b"L"', 97, 19, 97, 23),
woosh.Token(woosh.COMMENT, '# GNU tar longname', 97, 32, 97, 50),
woosh.Token(woosh.NEWLINE, '\r\n', 97, 50, 98, 0),
woosh.Token(woosh.NAME, 'GNUTYPE_LONGLINK', 98, 0, 98, 16),
woosh.Token(woosh.OP, '=', 98, 17, 98, 18),
woosh.Token(woosh.STRING, 'b"K"', 98, 19, 98, 23),
woosh.Token(woosh.COMMENT, '# GNU tar longlink', 98, 32, 98, 50),
woosh.Token(woosh.NEWLINE, '\r\n', 98, 50, 99, 0),
woosh.Token(woosh.NAME, 'GNUTYPE_SPARSE', 99, 0, 99, 14),
woosh.Token(woosh.OP, '=', 99, 15, 99, 16),
woosh.Token(woosh.STRING, 'b"S"', 99, 17, 99, 21),
woosh.Token(woosh.COMMENT, '# GNU tar sparse file', 99, 32, 99, 53),
woosh.Token(woosh.NEWLINE, '\r\n', 99, 53, 100, 0),
woosh.Token(woosh.NAME, 'XHDTYPE', 101, 0, 101, 7),
woosh.Token(woosh.OP, '=', 101, 8, 101, 9),
woosh.Token(woosh.STRING, 'b"x"', 101, 10, 101, 14),
woosh.Token(woosh.COMMENT, '# POSIX.1-2001 extended header', 101, 32, 101, 62),
woosh.Token(woosh.NEWLINE, '\r\n', 101, 62, 102, 0),
woosh.Token(woosh.NAME, 'XGLTYPE', 102, 0, 102, 7),
woosh.Token(woosh.OP, '=', 102, 8, 102, 9),
woosh.Token(woosh.STRING, 'b"g"', 102, 10, 102, 14),
woosh.Token(woosh.COMMENT, '# POSIX.1-2001 global header', 102, 32, 102, 60),
woosh.Token(woosh.NEWLINE, '\r\n', 102, 60, 103, 0),
woosh.Token(woosh.NAME, 'SOLARIS_XHDTYPE', 103, 0, 103, 15),
woosh.Token(woosh.OP, '=', 103, 16, 103, 17),
woosh.Token(woosh.STRING, 'b"X"', 103, 18, 103, 22),
woosh.Token(woosh.COMMENT, '# Solaris extended header', 103, 32, 103, 57),
woosh.Token(woosh.NEWLINE, '\r\n', 103, 57, 104, 0),
woosh.Token(woosh.NAME, 'USTAR_FORMAT', 105, 0, 105, 12),
woosh.Token(woosh.OP, '=', 105, 13, 105, 14),
woosh.Token(woosh.NUMBER, '0', 105, 15, 105, 16),
woosh.Token(woosh.COMMENT, '# POSIX.1-1988 (ustar) format', 105, 32, 105, 61),
woosh.Token(woosh.NEWLINE, '\r\n', 105, 61, 106, 0),
woosh.Token(woosh.NAME, 'GNU_FORMAT', 106, 0, 106, 10),
woosh.Token(woosh.OP, '=', 106, 11, 106, 12),
woosh.Token(woosh.NUMBER, '1', 106, 13, 106, 14),
woosh.Token(woosh.COMMENT, '# GNU tar format', 106, 32, 106, 48),
woosh.Token(woosh.NEWLINE, '\r\n', 106, 48, 107, 0),
woosh.Token(woosh.NAME, 'PAX_FORMAT', 107, 0, 107, 10),
woosh.Token(woosh.OP, '=', 107, 11, 107, 12),
woosh.Token(woosh.NUMBER, '2', 107, 13, 107, 14),
woosh.Token(woosh.COMMENT, '# POSIX.1-2001 (pax) format', 107, 32, 107, 59),
woosh.Token(woosh.NEWLINE, '\r\n', 107, 59, 108, 0),
woosh.Token(woosh.NAME, 'DEFAULT_FORMAT', 108, 0, 108, 14),
woosh.Token(woosh.OP, '=', 108, 15, 108, 16),
woosh.Token(woosh.NAME, 'PAX_FORMAT', 108, 17, 108, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 108, 27, 109, 0),
woosh.Token(woosh.COMMENT, '#---------------------------------------------------------', 110, 0, 110, 58),
woosh.Token(woosh.COMMENT, '# tarfile constants', 111, 0, 111, 19),
woosh.Token(woosh.COMMENT, '#---------------------------------------------------------', 112, 0, 112, 58),
woosh.Token(woosh.COMMENT, '# File types that tarfile supports:', 113, 0, 113, 35),
woosh.Token(woosh.NAME, 'SUPPORTED_TYPES', 114, 0, 114, 15),
woosh.Token(woosh.OP, '=', 114, 16, 114, 17),
woosh.Token(woosh.OP, '(', 114, 18, 114, 19),
woosh.Token(woosh.NAME, 'REGTYPE', 114, 19, 114, 26),
woosh.Token(woosh.OP, ',', 114, 26, 114, 27),
woosh.Token(woosh.NAME, 'AREGTYPE', 114, 28, 114, 36),
woosh.Token(woosh.OP, ',', 114, 36, 114, 37),
woosh.Token(woosh.NAME, 'LNKTYPE', 114, 38, 114, 45),
woosh.Token(woosh.OP, ',', 114, 45, 114, 46),
woosh.Token(woosh.NAME, 'SYMTYPE', 115, 19, 115, 26),
woosh.Token(woosh.OP, ',', 115, 26, 115, 27),
woosh.Token(woosh.NAME, 'DIRTYPE', 115, 28, 115, 35),
woosh.Token(woosh.OP, ',', 115, 35, 115, 36),
woosh.Token(woosh.NAME, 'FIFOTYPE', 115, 37, 115, 45),
woosh.Token(woosh.OP, ',', 115, 45, 115, 46),
woosh.Token(woosh.NAME, 'CONTTYPE', 116, 19, 116, 27),
woosh.Token(woosh.OP, ',', 116, 27, 116, 28),
woosh.Token(woosh.NAME, 'CHRTYPE', 116, 29, 116, 36),
woosh.Token(woosh.OP, ',', 116, 36, 116, 37),
woosh.Token(woosh.NAME, 'BLKTYPE', 116, 38, 116, 45),
woosh.Token(woosh.OP, ',', 116, 45, 116, 46),
woosh.Token(woosh.NAME, 'GNUTYPE_LONGNAME', 117, 19, 117, 35),
woosh.Token(woosh.OP, ',', 117, 35, 117, 36),
woosh.Token(woosh.NAME, 'GNUTYPE_LONGLINK', 117, 37, 117, 53),
woosh.Token(woosh.OP, ',', 117, 53, 117, 54),
woosh.Token(woosh.NAME, 'GNUTYPE_SPARSE', 118, 19, 118, 33),
woosh.Token(woosh.OP, ')', 118, 33, 118, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 118, 34, 119, 0),
woosh.Token(woosh.COMMENT, '# File types that will be treated as a regular file.', 120, 0, 120, 52),
woosh.Token(woosh.NAME, 'REGULAR_TYPES', 121, 0, 121, 13),
woosh.Token(woosh.OP, '=', 121, 14, 121, 15),
woosh.Token(woosh.OP, '(', 121, 16, 121, 17),
woosh.Token(woosh.NAME, 'REGTYPE', 121, 17, 121, 24),
woosh.Token(woosh.OP, ',', 121, 24, 121, 25),
woosh.Token(woosh.NAME, 'AREGTYPE', 121, 26, 121, 34),
woosh.Token(woosh.OP, ',', 121, 34, 121, 35),
woosh.Token(woosh.NAME, 'CONTTYPE', 122, 17, 122, 25),
woosh.Token(woosh.OP, ',', 122, 25, 122, 26),
woosh.Token(woosh.NAME, 'GNUTYPE_SPARSE', 122, 27, 122, 41),
woosh.Token(woosh.OP, ')', 122, 41, 122, 42),
woosh.Token(woosh.NEWLINE, '\r\n', 122, 42, 123, 0),
woosh.Token(woosh.COMMENT, '# File types that are part of the GNU tar format.', 124, 0, 124, 49),
woosh.Token(woosh.NAME, 'GNU_TYPES', 125, 0, 125, 9),
woosh.Token(woosh.OP, '=', 125, 10, 125, 11),
woosh.Token(woosh.OP, '(', 125, 12, 125, 13),
woosh.Token(woosh.NAME, 'GNUTYPE_LONGNAME', 125, 13, 125, 29),
woosh.Token(woosh.OP, ',', 125, 29, 125, 30),
woosh.Token(woosh.NAME, 'GNUTYPE_LONGLINK', 125, 31, 125, 47),
woosh.Token(woosh.OP, ',', 125, 47, 125, 48),
woosh.Token(woosh.NAME, 'GNUTYPE_SPARSE', 126, 13, 126, 27),
woosh.Token(woosh.OP, ')', 126, 27, 126, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 126, 28, 127, 0),
woosh.Token(woosh.COMMENT, '# Fields from a pax header that override a TarInfo attribute.', 128, 0, 128, 61),
woosh.Token(woosh.NAME, 'PAX_FIELDS', 129, 0, 129, 10),
woosh.Token(woosh.OP, '=', 129, 11, 129, 12),
woosh.Token(woosh.OP, '(', 129, 13, 129, 14),
woosh.Token(woosh.STRING, '"path"', 129, 14, 129, 20),
woosh.Token(woosh.OP, ',', 129, 20, 129, 21),
woosh.Token(woosh.STRING, '"linkpath"', 129, 22, 129, 32),
woosh.Token(woosh.OP, ',', 129, 32, 129, 33),
woosh.Token(woosh.STRING, '"size"', 129, 34, 129, 40),
woosh.Token(woosh.OP, ',', 129, 40, 129, 41),
woosh.Token(woosh.STRING, '"mtime"', 129, 42, 129, 49),
woosh.Token(woosh.OP, ',', 129, 49, 129, 50),
woosh.Token(woosh.STRING, '"uid"', 130, 14, 130, 19),
woosh.Token(woosh.OP, ',', 130, 19, 130, 20),
woosh.Token(woosh.STRING, '"gid"', 130, 21, 130, 26),
woosh.Token(woosh.OP, ',', 130, 26, 130, 27),
woosh.Token(woosh.STRING, '"uname"', 130, 28, 130, 35),
woosh.Token(woosh.OP, ',', 130, 35, 130, 36),
woosh.Token(woosh.STRING, '"gname"', 130, 37, 130, 44),
woosh.Token(woosh.OP, ')', 130, 44, 130, 45),
woosh.Token(woosh.NEWLINE, '\r\n', 130, 45, 131, 0),
woosh.Token(woosh.COMMENT, '# Fields from a pax header that are affected by hdrcharset.', 132, 0, 132, 59),
woosh.Token(woosh.NAME, 'PAX_NAME_FIELDS', 133, 0, 133, 15),
woosh.Token(woosh.OP, '=', 133, 16, 133, 17),
woosh.Token(woosh.OP, '{', 133, 18, 133, 19),
woosh.Token(woosh.STRING, '"path"', 133, 19, 133, 25),
woosh.Token(woosh.OP, ',', 133, 25, 133, 26),
woosh.Token(woosh.STRING, '"linkpath"', 133, 27, 133, 37),
woosh.Token(woosh.OP, ',', 133, 37, 133, 38),
woosh.Token(woosh.STRING, '"uname"', 133, 39, 133, 46),
woosh.Token(woosh.OP, ',', 133, 46, 133, 47),
woosh.Token(woosh.STRING, '"gname"', 133, 48, 133, 55),
woosh.Token(woosh.OP, '}', 133, 55, 133, 56),
woosh.Token(woosh.NEWLINE, '\r\n', 133, 56, 134, 0),
woosh.Token(woosh.COMMENT, '# Fields in a pax header that are numbers, all other fields', 135, 0, 135, 59),
woosh.Token(woosh.COMMENT, '# are treated as strings.', 136, 0, 136, 25),
woosh.Token(woosh.NAME, 'PAX_NUMBER_FIELDS', 137, 0, 137, 17),
woosh.Token(woosh.OP, '=', 137, 18, 137, 19),
woosh.Token(woosh.OP, '{', 137, 20, 137, 21),
woosh.Token(woosh.STRING, '"atime"', 138, 4, 138, 11),
woosh.Token(woosh.OP, ':', 138, 11, 138, 12),
woosh.Token(woosh.NAME, 'float', 138, 13, 138, 18),
woosh.Token(woosh.OP, ',', 138, 18, 138, 19),
woosh.Token(woosh.STRING, '"ctime"', 139, 4, 139, 11),
woosh.Token(woosh.OP, ':', 139, 11, 139, 12),
woosh.Token(woosh.NAME, 'float', 139, 13, 139, 18),
woosh.Token(woosh.OP, ',', 139, 18, 139, 19),
woosh.Token(woosh.STRING, '"mtime"', 140, 4, 140, 11),
woosh.Token(woosh.OP, ':', 140, 11, 140, 12),
woosh.Token(woosh.NAME, 'float', 140, 13, 140, 18),
woosh.Token(woosh.OP, ',', 140, 18, 140, 19),
woosh.Token(woosh.STRING, '"uid"', 141, 4, 141, 9),
woosh.Token(woosh.OP, ':', 141, 9, 141, 10),
woosh.Token(woosh.NAME, 'int', 141, 11, 141, 14),
woosh.Token(woosh.OP, ',', 141, 14, 141, 15),
woosh.Token(woosh.STRING, '"gid"', 142, 4, 142, 9),
woosh.Token(woosh.OP, ':', 142, 9, 142, 10),
woosh.Token(woosh.NAME, 'int', 142, 11, 142, 14),
woosh.Token(woosh.OP, ',', 142, 14, 142, 15),
woosh.Token(woosh.STRING, '"size"', 143, 4, 143, 10),
woosh.Token(woosh.OP, ':', 143, 10, 143, 11),
woosh.Token(woosh.NAME, 'int', 143, 12, 143, 15),
woosh.Token(woosh.OP, '}', 144, 0, 144, 1),
woosh.Token(woosh.NEWLINE, '\r\n', 144, 1, 145, 0),
woosh.Token(woosh.COMMENT, '#---------------------------------------------------------', 146, 0, 146, 58),
woosh.Token(woosh.COMMENT, '# initialization', 147, 0, 147, 16),
woosh.Token(woosh.COMMENT, '#---------------------------------------------------------', 148, 0, 148, 58),
woosh.Token(woosh.NAME, 'if', 149, 0, 149, 2),
woosh.Token(woosh.NAME, 'os', 149, 3, 149, 5),
woosh.Token(woosh.OP, '.', 149, 5, 149, 6),
woosh.Token(woosh.NAME, 'name', 149, 6, 149, 10),
woosh.Token(woosh.OP, '==', 149, 11, 149, 13),
woosh.Token(woosh.STRING, '"nt"', 149, 14, 149, 18),
woosh.Token(woosh.OP, ':', 149, 18, 149, 19),
woosh.Token(woosh.NEWLINE, '\r\n', 149, 19, 150, 0),
woosh.Token(woosh.INDENT, ' ', 150, 0, 150, 4),
woosh.Token(woosh.NAME, 'ENCODING', 150, 4, 150, 12),
woosh.Token(woosh.OP, '=', 150, 13, 150, 14),
woosh.Token(woosh.STRING, '"utf-8"', 150, 15, 150, 22),
woosh.Token(woosh.NEWLINE, '\r\n', 150, 22, 151, 0),
woosh.Token(woosh.DEDENT, '', 151, 0, 151, 0),
woosh.Token(woosh.NAME, 'else', 151, 0, 151, 4),
woosh.Token(woosh.OP, ':', 151, 4, 151, 5),
woosh.Token(woosh.NEWLINE, '\r\n', 151, 5, 152, 0),
woosh.Token(woosh.INDENT, ' ', 152, 0, 152, 4),
woosh.Token(woosh.NAME, 'ENCODING', 152, 4, 152, 12),
woosh.Token(woosh.OP, '=', 152, 13, 152, 14),
woosh.Token(woosh.NAME, 'sys', 152, 15, 152, 18),
woosh.Token(woosh.OP, '.', 152, 18, 152, 19),
woosh.Token(woosh.NAME, 'getfilesystemencoding', 152, 19, 152, 40),
woosh.Token(woosh.OP, '(', 152, 40, 152, 41),
woosh.Token(woosh.OP, ')', 152, 41, 152, 42),
woosh.Token(woosh.NEWLINE, '\r\n', 152, 42, 153, 0),
woosh.Token(woosh.COMMENT, '#---------------------------------------------------------', 154, 0, 154, 58),
woosh.Token(woosh.COMMENT, '# Some useful functions', 155, 0, 155, 23),
woosh.Token(woosh.COMMENT, '#---------------------------------------------------------', 156, 0, 156, 58),
woosh.Token(woosh.DEDENT, '', 158, 0, 158, 0),
woosh.Token(woosh.NAME, 'def', 158, 0, 158, 3),
woosh.Token(woosh.NAME, 'stn', 158, 4, 158, 7),
woosh.Token(woosh.OP, '(', 158, 7, 158, 8),
woosh.Token(woosh.NAME, 's', 158, 8, 158, 9),
woosh.Token(woosh.OP, ',', 158, 9, 158, 10),
woosh.Token(woosh.NAME, 'length', 158, 11, 158, 17),
woosh.Token(woosh.OP, ',', 158, 17, 158, 18),
woosh.Token(woosh.NAME, 'encoding', 158, 19, 158, 27),
woosh.Token(woosh.OP, ',', 158, 27, 158, 28),
woosh.Token(woosh.NAME, 'errors', 158, 29, 158, 35),
woosh.Token(woosh.OP, ')', 158, 35, 158, 36),
woosh.Token(woosh.OP, ':', 158, 36, 158, 37),
woosh.Token(woosh.NEWLINE, '\r\n', 158, 37, 159, 0),
woosh.Token(woosh.INDENT, ' ', 159, 0, 159, 4),
woosh.Token(woosh.STRING, '"""Convert a string to a null-terminated bytes object.\r\n """', 159, 4, 160, 7),
woosh.Token(woosh.NEWLINE, '\r\n', 160, 7, 161, 0),
woosh.Token(woosh.NAME, 's', 161, 4, 161, 5),
woosh.Token(woosh.OP, '=', 161, 6, 161, 7),
woosh.Token(woosh.NAME, 's', 161, 8, 161, 9),
woosh.Token(woosh.OP, '.', 161, 9, 161, 10),
woosh.Token(woosh.NAME, 'encode', 161, 10, 161, 16),
woosh.Token(woosh.OP, '(', 161, 16, 161, 17),
woosh.Token(woosh.NAME, 'encoding', 161, 17, 161, 25),
woosh.Token(woosh.OP, ',', 161, 25, 161, 26),
woosh.Token(woosh.NAME, 'errors', 161, 27, 161, 33),
woosh.Token(woosh.OP, ')', 161, 33, 161, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 161, 34, 162, 0),
woosh.Token(woosh.NAME, 'return', 162, 4, 162, 10),
woosh.Token(woosh.NAME, 's', 162, 11, 162, 12),
woosh.Token(woosh.OP, '[', 162, 12, 162, 13),
woosh.Token(woosh.OP, ':', 162, 13, 162, 14),
woosh.Token(woosh.NAME, 'length', 162, 14, 162, 20),
woosh.Token(woosh.OP, ']', 162, 20, 162, 21),
woosh.Token(woosh.OP, '+', 162, 22, 162, 23),
woosh.Token(woosh.OP, '(', 162, 24, 162, 25),
woosh.Token(woosh.NAME, 'length', 162, 25, 162, 31),
woosh.Token(woosh.OP, '-', 162, 32, 162, 33),
woosh.Token(woosh.NAME, 'len', 162, 34, 162, 37),
woosh.Token(woosh.OP, '(', 162, 37, 162, 38),
woosh.Token(woosh.NAME, 's', 162, 38, 162, 39),
woosh.Token(woosh.OP, ')', 162, 39, 162, 40),
woosh.Token(woosh.OP, ')', 162, 40, 162, 41),
woosh.Token(woosh.OP, '*', 162, 42, 162, 43),
woosh.Token(woosh.NAME, 'NUL', 162, 44, 162, 47),
woosh.Token(woosh.NEWLINE, '\r\n', 162, 47, 163, 0),
woosh.Token(woosh.DEDENT, '', 164, 0, 164, 0),
woosh.Token(woosh.NAME, 'def', 164, 0, 164, 3),
woosh.Token(woosh.NAME, 'nts', 164, 4, 164, 7),
woosh.Token(woosh.OP, '(', 164, 7, 164, 8),
woosh.Token(woosh.NAME, 's', 164, 8, 164, 9),
woosh.Token(woosh.OP, ',', 164, 9, 164, 10),
woosh.Token(woosh.NAME, 'encoding', 164, 11, 164, 19),
woosh.Token(woosh.OP, ',', 164, 19, 164, 20),
woosh.Token(woosh.NAME, 'errors', 164, 21, 164, 27),
woosh.Token(woosh.OP, ')', 164, 27, 164, 28),
woosh.Token(woosh.OP, ':', 164, 28, 164, 29),
woosh.Token(woosh.NEWLINE, '\r\n', 164, 29, 165, 0),
woosh.Token(woosh.INDENT, ' ', 165, 0, 165, 4),
woosh.Token(woosh.STRING, '"""Convert a null-terminated bytes object to a string.\r\n """', 165, 4, 166, 7),
woosh.Token(woosh.NEWLINE, '\r\n', 166, 7, 167, 0),
woosh.Token(woosh.NAME, 'p', 167, 4, 167, 5),
woosh.Token(woosh.OP, '=', 167, 6, 167, 7),
woosh.Token(woosh.NAME, 's', 167, 8, 167, 9),
woosh.Token(woosh.OP, '.', 167, 9, 167, 10),
woosh.Token(woosh.NAME, 'find', 167, 10, 167, 14),
woosh.Token(woosh.OP, '(', 167, 14, 167, 15),
woosh.Token(woosh.STRING, 'b"\\0"', 167, 15, 167, 20),
woosh.Token(woosh.OP, ')', 167, 20, 167, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 167, 21, 168, 0),
woosh.Token(woosh.NAME, 'if', 168, 4, 168, 6),
woosh.Token(woosh.NAME, 'p', 168, 7, 168, 8),
woosh.Token(woosh.OP, '!=', 168, 9, 168, 11),
woosh.Token(woosh.OP, '-', 168, 12, 168, 13),
woosh.Token(woosh.NUMBER, '1', 168, 13, 168, 14),
woosh.Token(woosh.OP, ':', 168, 14, 168, 15),
woosh.Token(woosh.NEWLINE, '\r\n', 168, 15, 169, 0),
woosh.Token(woosh.INDENT, ' ', 169, 0, 169, 8),
woosh.Token(woosh.NAME, 's', 169, 8, 169, 9),
woosh.Token(woosh.OP, '=', 169, 10, 169, 11),
woosh.Token(woosh.NAME, 's', 169, 12, 169, 13),
woosh.Token(woosh.OP, '[', 169, 13, 169, 14),
woosh.Token(woosh.OP, ':', 169, 14, 169, 15),
woosh.Token(woosh.NAME, 'p', 169, 15, 169, 16),
woosh.Token(woosh.OP, ']', 169, 16, 169, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 169, 17, 170, 0),
woosh.Token(woosh.DEDENT, ' ', 170, 0, 170, 4),
woosh.Token(woosh.NAME, 'return', 170, 4, 170, 10),
woosh.Token(woosh.NAME, 's', 170, 11, 170, 12),
woosh.Token(woosh.OP, '.', 170, 12, 170, 13),
woosh.Token(woosh.NAME, 'decode', 170, 13, 170, 19),
woosh.Token(woosh.OP, '(', 170, 19, 170, 20),
woosh.Token(woosh.NAME, 'encoding', 170, 20, 170, 28),
woosh.Token(woosh.OP, ',', 170, 28, 170, 29),
woosh.Token(woosh.NAME, 'errors', 170, 30, 170, 36),
woosh.Token(woosh.OP, ')', 170, 36, 170, 37),
woosh.Token(woosh.NEWLINE, '\r\n', 170, 37, 171, 0),
woosh.Token(woosh.DEDENT, '', 172, 0, 172, 0),
woosh.Token(woosh.NAME, 'def', 172, 0, 172, 3),
woosh.Token(woosh.NAME, 'nti', 172, 4, 172, 7),
woosh.Token(woosh.OP, '(', 172, 7, 172, 8),
woosh.Token(woosh.NAME, 's', 172, 8, 172, 9),
woosh.Token(woosh.OP, ')', 172, 9, 172, 10),
woosh.Token(woosh.OP, ':', 172, 10, 172, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 172, 11, 173, 0),
woosh.Token(woosh.INDENT, ' ', 173, 0, 173, 4),
woosh.Token(woosh.STRING, '"""Convert a number field to a python number.\r\n """', 173, 4, 174, 7),
woosh.Token(woosh.NEWLINE, '\r\n', 174, 7, 175, 0),
woosh.Token(woosh.COMMENT, '# There are two possible encodings for a number field, see', 175, 4, 175, 62),
woosh.Token(woosh.COMMENT, '# itn() below.', 176, 4, 176, 18),
woosh.Token(woosh.NAME, 'if', 177, 4, 177, 6),
woosh.Token(woosh.NAME, 's', 177, 7, 177, 8),
woosh.Token(woosh.OP, '[', 177, 8, 177, 9),
woosh.Token(woosh.NUMBER, '0', 177, 9, 177, 10),
woosh.Token(woosh.OP, ']', 177, 10, 177, 11),
woosh.Token(woosh.NAME, 'in', 177, 12, 177, 14),
woosh.Token(woosh.OP, '(', 177, 15, 177, 16),
woosh.Token(woosh.NUMBER, '0o200', 177, 16, 177, 21),
woosh.Token(woosh.OP, ',', 177, 21, 177, 22),
woosh.Token(woosh.NUMBER, '0o377', 177, 23, 177, 28),
woosh.Token(woosh.OP, ')', 177, 28, 177, 29),
woosh.Token(woosh.OP, ':', 177, 29, 177, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 177, 30, 178, 0),
woosh.Token(woosh.INDENT, ' ', 178, 0, 178, 8),
woosh.Token(woosh.NAME, 'n', 178, 8, 178, 9),
woosh.Token(woosh.OP, '=', 178, 10, 178, 11),
woosh.Token(woosh.NUMBER, '0', 178, 12, 178, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 178, 13, 179, 0),
woosh.Token(woosh.NAME, 'for', 179, 8, 179, 11),
woosh.Token(woosh.NAME, 'i', 179, 12, 179, 13),
woosh.Token(woosh.NAME, 'in', 179, 14, 179, 16),
woosh.Token(woosh.NAME, 'range', 179, 17, 179, 22),
woosh.Token(woosh.OP, '(', 179, 22, 179, 23),
woosh.Token(woosh.NAME, 'len', 179, 23, 179, 26),
woosh.Token(woosh.OP, '(', 179, 26, 179, 27),
woosh.Token(woosh.NAME, 's', 179, 27, 179, 28),
woosh.Token(woosh.OP, ')', 179, 28, 179, 29),
woosh.Token(woosh.OP, '-', 179, 30, 179, 31),
woosh.Token(woosh.NUMBER, '1', 179, 32, 179, 33),
woosh.Token(woosh.OP, ')', 179, 33, 179, 34),
woosh.Token(woosh.OP, ':', 179, 34, 179, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 179, 35, 180, 0),
woosh.Token(woosh.INDENT, ' ', 180, 0, 180, 12),
woosh.Token(woosh.NAME, 'n', 180, 12, 180, 13),
woosh.Token(woosh.OP, '<<=', 180, 14, 180, 17),
woosh.Token(woosh.NUMBER, '8', 180, 18, 180, 19),
woosh.Token(woosh.NEWLINE, '\r\n', 180, 19, 181, 0),
woosh.Token(woosh.NAME, 'n', 181, 12, 181, 13),
woosh.Token(woosh.OP, '+=', 181, 14, 181, 16),
woosh.Token(woosh.NAME, 's', 181, 17, 181, 18),
woosh.Token(woosh.OP, '[', 181, 18, 181, 19),
woosh.Token(woosh.NAME, 'i', 181, 19, 181, 20),
woosh.Token(woosh.OP, '+', 181, 21, 181, 22),
woosh.Token(woosh.NUMBER, '1', 181, 23, 181, 24),
woosh.Token(woosh.OP, ']', 181, 24, 181, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 181, 25, 182, 0),
woosh.Token(woosh.DEDENT, ' ', 182, 0, 182, 8),
woosh.Token(woosh.NAME, 'if', 182, 8, 182, 10),
woosh.Token(woosh.NAME, 's', 182, 11, 182, 12),
woosh.Token(woosh.OP, '[', 182, 12, 182, 13),
woosh.Token(woosh.NUMBER, '0', 182, 13, 182, 14),
woosh.Token(woosh.OP, ']', 182, 14, 182, 15),
woosh.Token(woosh.OP, '==', 182, 16, 182, 18),
woosh.Token(woosh.NUMBER, '0o377', 182, 19, 182, 24),
woosh.Token(woosh.OP, ':', 182, 24, 182, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 182, 25, 183, 0),
woosh.Token(woosh.INDENT, ' ', 183, 0, 183, 12),
woosh.Token(woosh.NAME, 'n', 183, 12, 183, 13),
woosh.Token(woosh.OP, '=', 183, 14, 183, 15),
woosh.Token(woosh.OP, '-', 183, 16, 183, 17),
woosh.Token(woosh.OP, '(', 183, 17, 183, 18),
woosh.Token(woosh.NUMBER, '256', 183, 18, 183, 21),
woosh.Token(woosh.OP, '**', 183, 22, 183, 24),
woosh.Token(woosh.OP, '(', 183, 25, 183, 26),
woosh.Token(woosh.NAME, 'len', 183, 26, 183, 29),
woosh.Token(woosh.OP, '(', 183, 29, 183, 30),
woosh.Token(woosh.NAME, 's', 183, 30, 183, 31),
woosh.Token(woosh.OP, ')', 183, 31, 183, 32),
woosh.Token(woosh.OP, '-', 183, 33, 183, 34),
woosh.Token(woosh.NUMBER, '1', 183, 35, 183, 36),
woosh.Token(woosh.OP, ')', 183, 36, 183, 37),
woosh.Token(woosh.OP, '-', 183, 38, 183, 39),
woosh.Token(woosh.NAME, 'n', 183, 40, 183, 41),
woosh.Token(woosh.OP, ')', 183, 41, 183, 42),
woosh.Token(woosh.NEWLINE, '\r\n', 183, 42, 184, 0),
woosh.Token(woosh.DEDENT, ' ', 184, 0, 184, 4),
woosh.Token(woosh.DEDENT, '', 184, 4, 184, 4),
woosh.Token(woosh.NAME, 'else', 184, 4, 184, 8),
woosh.Token(woosh.OP, ':', 184, 8, 184, 9),
woosh.Token(woosh.NEWLINE, '\r\n', 184, 9, 185, 0),
woosh.Token(woosh.INDENT, ' ', 185, 0, 185, 8),
woosh.Token(woosh.NAME, 'try', 185, 8, 185, 11),
woosh.Token(woosh.OP, ':', 185, 11, 185, 12),
woosh.Token(woosh.NEWLINE, '\r\n', 185, 12, 186, 0),
woosh.Token(woosh.INDENT, ' ', 186, 0, 186, 12),
woosh.Token(woosh.NAME, 's', 186, 12, 186, 13),
woosh.Token(woosh.OP, '=', 186, 14, 186, 15),
woosh.Token(woosh.NAME, 'nts', 186, 16, 186, 19),
woosh.Token(woosh.OP, '(', 186, 19, 186, 20),
woosh.Token(woosh.NAME, 's', 186, 20, 186, 21),
woosh.Token(woosh.OP, ',', 186, 21, 186, 22),
woosh.Token(woosh.STRING, '"ascii"', 186, 23, 186, 30),
woosh.Token(woosh.OP, ',', 186, 30, 186, 31),
woosh.Token(woosh.STRING, '"strict"', 186, 32, 186, 40),
woosh.Token(woosh.OP, ')', 186, 40, 186, 41),
woosh.Token(woosh.NEWLINE, '\r\n', 186, 41, 187, 0),
woosh.Token(woosh.NAME, 'n', 187, 12, 187, 13),
woosh.Token(woosh.OP, '=', 187, 14, 187, 15),
woosh.Token(woosh.NAME, 'int', 187, 16, 187, 19),
woosh.Token(woosh.OP, '(', 187, 19, 187, 20),
woosh.Token(woosh.NAME, 's', 187, 20, 187, 21),
woosh.Token(woosh.OP, '.', 187, 21, 187, 22),
woosh.Token(woosh.NAME, 'strip', 187, 22, 187, 27),
woosh.Token(woosh.OP, '(', 187, 27, 187, 28),
woosh.Token(woosh.OP, ')', 187, 28, 187, 29),
woosh.Token(woosh.NAME, 'or', 187, 30, 187, 32),
woosh.Token(woosh.STRING, '"0"', 187, 33, 187, 36),
woosh.Token(woosh.OP, ',', 187, 36, 187, 37),
woosh.Token(woosh.NUMBER, '8', 187, 38, 187, 39),
woosh.Token(woosh.OP, ')', 187, 39, 187, 40),
woosh.Token(woosh.NEWLINE, '\r\n', 187, 40, 188, 0),
woosh.Token(woosh.DEDENT, ' ', 188, 0, 188, 8),
woosh.Token(woosh.NAME, 'except', 188, 8, 188, 14),
woosh.Token(woosh.NAME, 'ValueError', 188, 15, 188, 25),
woosh.Token(woosh.OP, ':', 188, 25, 188, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 188, 26, 189, 0),
woosh.Token(woosh.INDENT, ' ', 189, 0, 189, 12),
woosh.Token(woosh.NAME, 'raise', 189, 12, 189, 17),
woosh.Token(woosh.NAME, 'InvalidHeaderError', 189, 18, 189, 36),
woosh.Token(woosh.OP, '(', 189, 36, 189, 37),
woosh.Token(woosh.STRING, '"invalid header"', 189, 37, 189, 53),
woosh.Token(woosh.OP, ')', 189, 53, 189, 54),
woosh.Token(woosh.NEWLINE, '\r\n', 189, 54, 190, 0),
woosh.Token(woosh.DEDENT, ' ', 190, 0, 190, 4),
woosh.Token(woosh.DEDENT, '', 190, 4, 190, 4),
woosh.Token(woosh.NAME, 'return', 190, 4, 190, 10),
woosh.Token(woosh.NAME, 'n', 190, 11, 190, 12),
woosh.Token(woosh.NEWLINE, '\r\n', 190, 12, 191, 0),
woosh.Token(woosh.DEDENT, '', 192, 0, 192, 0),
woosh.Token(woosh.NAME, 'def', 192, 0, 192, 3),
woosh.Token(woosh.NAME, 'itn', 192, 4, 192, 7),
woosh.Token(woosh.OP, '(', 192, 7, 192, 8),
woosh.Token(woosh.NAME, 'n', 192, 8, 192, 9),
woosh.Token(woosh.OP, ',', 192, 9, 192, 10),
woosh.Token(woosh.NAME, 'digits', 192, 11, 192, 17),
woosh.Token(woosh.OP, '=', 192, 17, 192, 18),
woosh.Token(woosh.NUMBER, '8', 192, 18, 192, 19),
woosh.Token(woosh.OP, ',', 192, 19, 192, 20),
woosh.Token(woosh.NAME, 'format', 192, 21, 192, 27),
woosh.Token(woosh.OP, '=', 192, 27, 192, 28),
woosh.Token(woosh.NAME, 'DEFAULT_FORMAT', 192, 28, 192, 42),
woosh.Token(woosh.OP, ')', 192, 42, 192, 43),
woosh.Token(woosh.OP, ':', 192, 43, 192, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 192, 44, 193, 0),
woosh.Token(woosh.INDENT, ' ', 193, 0, 193, 4),
woosh.Token(woosh.STRING, '"""Convert a python number to a number field.\r\n """', 193, 4, 194, 7),
woosh.Token(woosh.NEWLINE, '\r\n', 194, 7, 195, 0),
woosh.Token(woosh.COMMENT, '# POSIX 1003.1-1988 requires numbers to be encoded as a string of', 195, 4, 195, 69),
woosh.Token(woosh.COMMENT, '# octal digits followed by a null-byte, this allows values up to', 196, 4, 196, 68),
woosh.Token(woosh.COMMENT, '# (8**(digits-1))-1. GNU tar allows storing numbers greater than', 197, 4, 197, 68),
woosh.Token(woosh.COMMENT, '# that if necessary. A leading 0o200 or 0o377 byte indicate this', 198, 4, 198, 68),
woosh.Token(woosh.COMMENT, '# particular encoding, the following digits-1 bytes are a big-endian', 199, 4, 199, 72),
woosh.Token(woosh.COMMENT, '# base-256 representation. This allows values up to (256**(digits-1))-1.', 200, 4, 200, 76),
woosh.Token(woosh.COMMENT, '# A 0o200 byte indicates a positive number, a 0o377 byte a negative', 201, 4, 201, 71),
woosh.Token(woosh.COMMENT, '# number.', 202, 4, 202, 13),
woosh.Token(woosh.NAME, 'n', 203, 4, 203, 5),
woosh.Token(woosh.OP, '=', 203, 6, 203, 7),
woosh.Token(woosh.NAME, 'int', 203, 8, 203, 11),
woosh.Token(woosh.OP, '(', 203, 11, 203, 12),
woosh.Token(woosh.NAME, 'n', 203, 12, 203, 13),
woosh.Token(woosh.OP, ')', 203, 13, 203, 14),
woosh.Token(woosh.NEWLINE, '\r\n', 203, 14, 204, 0),
woosh.Token(woosh.NAME, 'if', 204, 4, 204, 6),
woosh.Token(woosh.NUMBER, '0', 204, 7, 204, 8),
woosh.Token(woosh.OP, '<=', 204, 9, 204, 11),
woosh.Token(woosh.NAME, 'n', 204, 12, 204, 13),
woosh.Token(woosh.OP, '<', 204, 14, 204, 15),
woosh.Token(woosh.NUMBER, '8', 204, 16, 204, 17),
woosh.Token(woosh.OP, '**', 204, 18, 204, 20),
woosh.Token(woosh.OP, '(', 204, 21, 204, 22),
woosh.Token(woosh.NAME, 'digits', 204, 22, 204, 28),
woosh.Token(woosh.OP, '-', 204, 29, 204, 30),
woosh.Token(woosh.NUMBER, '1', 204, 31, 204, 32),
woosh.Token(woosh.OP, ')', 204, 32, 204, 33),
woosh.Token(woosh.OP, ':', 204, 33, 204, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 204, 34, 205, 0),
woosh.Token(woosh.INDENT, ' ', 205, 0, 205, 8),
woosh.Token(woosh.NAME, 's', 205, 8, 205, 9),
woosh.Token(woosh.OP, '=', 205, 10, 205, 11),
woosh.Token(woosh.NAME, 'bytes', 205, 12, 205, 17),
woosh.Token(woosh.OP, '(', 205, 17, 205, 18),
woosh.Token(woosh.STRING, '"%0*o"', 205, 18, 205, 24),
woosh.Token(woosh.OP, '%', 205, 25, 205, 26),
woosh.Token(woosh.OP, '(', 205, 27, 205, 28),
woosh.Token(woosh.NAME, 'digits', 205, 28, 205, 34),
woosh.Token(woosh.OP, '-', 205, 35, 205, 36),
woosh.Token(woosh.NUMBER, '1', 205, 37, 205, 38),
woosh.Token(woosh.OP, ',', 205, 38, 205, 39),
woosh.Token(woosh.NAME, 'n', 205, 40, 205, 41),
woosh.Token(woosh.OP, ')', 205, 41, 205, 42),
woosh.Token(woosh.OP, ',', 205, 42, 205, 43),
woosh.Token(woosh.STRING, '"ascii"', 205, 44, 205, 51),
woosh.Token(woosh.OP, ')', 205, 51, 205, 52),
woosh.Token(woosh.OP, '+', 205, 53, 205, 54),
woosh.Token(woosh.NAME, 'NUL', 205, 55, 205, 58),
woosh.Token(woosh.NEWLINE, '\r\n', 205, 58, 206, 0),
woosh.Token(woosh.DEDENT, ' ', 206, 0, 206, 4),
woosh.Token(woosh.NAME, 'elif', 206, 4, 206, 8),
woosh.Token(woosh.NAME, 'format', 206, 9, 206, 15),
woosh.Token(woosh.OP, '==', 206, 16, 206, 18),
woosh.Token(woosh.NAME, 'GNU_FORMAT', 206, 19, 206, 29),
woosh.Token(woosh.NAME, 'and', 206, 30, 206, 33),
woosh.Token(woosh.OP, '-', 206, 34, 206, 35),
woosh.Token(woosh.NUMBER, '256', 206, 35, 206, 38),
woosh.Token(woosh.OP, '**', 206, 39, 206, 41),
woosh.Token(woosh.OP, '(', 206, 42, 206, 43),
woosh.Token(woosh.NAME, 'digits', 206, 43, 206, 49),
woosh.Token(woosh.OP, '-', 206, 50, 206, 51),
woosh.Token(woosh.NUMBER, '1', 206, 52, 206, 53),
woosh.Token(woosh.OP, ')', 206, 53, 206, 54),
woosh.Token(woosh.OP, '<=', 206, 55, 206, 57),
woosh.Token(woosh.NAME, 'n', 206, 58, 206, 59),
woosh.Token(woosh.OP, '<', 206, 60, 206, 61),
woosh.Token(woosh.NUMBER, '256', 206, 62, 206, 65),
woosh.Token(woosh.OP, '**', 206, 66, 206, 68),
woosh.Token(woosh.OP, '(', 206, 69, 206, 70),
woosh.Token(woosh.NAME, 'digits', 206, 70, 206, 76),
woosh.Token(woosh.OP, '-', 206, 77, 206, 78),
woosh.Token(woosh.NUMBER, '1', 206, 79, 206, 80),
woosh.Token(woosh.OP, ')', 206, 80, 206, 81),
woosh.Token(woosh.OP, ':', 206, 81, 206, 82),
woosh.Token(woosh.NEWLINE, '\r\n', 206, 82, 207, 0),
woosh.Token(woosh.INDENT, ' ', 207, 0, 207, 8),
woosh.Token(woosh.NAME, 'if', 207, 8, 207, 10),
woosh.Token(woosh.NAME, 'n', 207, 11, 207, 12),
woosh.Token(woosh.OP, '>=', 207, 13, 207, 15),
woosh.Token(woosh.NUMBER, '0', 207, 16, 207, 17),
woosh.Token(woosh.OP, ':', 207, 17, 207, 18),
woosh.Token(woosh.NEWLINE, '\r\n', 207, 18, 208, 0),
woosh.Token(woosh.INDENT, ' ', 208, 0, 208, 12),
woosh.Token(woosh.NAME, 's', 208, 12, 208, 13),
woosh.Token(woosh.OP, '=', 208, 14, 208, 15),
woosh.Token(woosh.NAME, 'bytearray', 208, 16, 208, 25),
woosh.Token(woosh.OP, '(', 208, 25, 208, 26),
woosh.Token(woosh.OP, '[', 208, 26, 208, 27),
woosh.Token(woosh.NUMBER, '0o200', 208, 27, 208, 32),
woosh.Token(woosh.OP, ']', 208, 32, 208, 33),
woosh.Token(woosh.OP, ')', 208, 33, 208, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 208, 34, 209, 0),
woosh.Token(woosh.DEDENT, ' ', 209, 0, 209, 8),
woosh.Token(woosh.NAME, 'else', 209, 8, 209, 12),
woosh.Token(woosh.OP, ':', 209, 12, 209, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 209, 13, 210, 0),
woosh.Token(woosh.INDENT, ' ', 210, 0, 210, 12),
woosh.Token(woosh.NAME, 's', 210, 12, 210, 13),
woosh.Token(woosh.OP, '=', 210, 14, 210, 15),
woosh.Token(woosh.NAME, 'bytearray', 210, 16, 210, 25),
woosh.Token(woosh.OP, '(', 210, 25, 210, 26),
woosh.Token(woosh.OP, '[', 210, 26, 210, 27),
woosh.Token(woosh.NUMBER, '0o377', 210, 27, 210, 32),
woosh.Token(woosh.OP, ']', 210, 32, 210, 33),
woosh.Token(woosh.OP, ')', 210, 33, 210, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 210, 34, 211, 0),
woosh.Token(woosh.NAME, 'n', 211, 12, 211, 13),
woosh.Token(woosh.OP, '=', 211, 14, 211, 15),
woosh.Token(woosh.NUMBER, '256', 211, 16, 211, 19),
woosh.Token(woosh.OP, '**', 211, 20, 211, 22),
woosh.Token(woosh.NAME, 'digits', 211, 23, 211, 29),
woosh.Token(woosh.OP, '+', 211, 30, 211, 31),
woosh.Token(woosh.NAME, 'n', 211, 32, 211, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 211, 33, 212, 0),
woosh.Token(woosh.DEDENT, ' ', 213, 0, 213, 8),
woosh.Token(woosh.NAME, 'for', 213, 8, 213, 11),
woosh.Token(woosh.NAME, 'i', 213, 12, 213, 13),
woosh.Token(woosh.NAME, 'in', 213, 14, 213, 16),
woosh.Token(woosh.NAME, 'range', 213, 17, 213, 22),
woosh.Token(woosh.OP, '(', 213, 22, 213, 23),
woosh.Token(woosh.NAME, 'digits', 213, 23, 213, 29),
woosh.Token(woosh.OP, '-', 213, 30, 213, 31),
woosh.Token(woosh.NUMBER, '1', 213, 32, 213, 33),
woosh.Token(woosh.OP, ')', 213, 33, 213, 34),
woosh.Token(woosh.OP, ':', 213, 34, 213, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 213, 35, 214, 0),
woosh.Token(woosh.INDENT, ' ', 214, 0, 214, 12),
woosh.Token(woosh.NAME, 's', 214, 12, 214, 13),
woosh.Token(woosh.OP, '.', 214, 13, 214, 14),
woosh.Token(woosh.NAME, 'insert', 214, 14, 214, 20),
woosh.Token(woosh.OP, '(', 214, 20, 214, 21),
woosh.Token(woosh.NUMBER, '1', 214, 21, 214, 22),
woosh.Token(woosh.OP, ',', 214, 22, 214, 23),
woosh.Token(woosh.NAME, 'n', 214, 24, 214, 25),
woosh.Token(woosh.OP, '&', 214, 26, 214, 27),
woosh.Token(woosh.NUMBER, '0o377', 214, 28, 214, 33),
woosh.Token(woosh.OP, ')', 214, 33, 214, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 214, 34, 215, 0),
woosh.Token(woosh.NAME, 'n', 215, 12, 215, 13),
woosh.Token(woosh.OP, '>>=', 215, 14, 215, 17),
woosh.Token(woosh.NUMBER, '8', 215, 18, 215, 19),
woosh.Token(woosh.NEWLINE, '\r\n', 215, 19, 216, 0),
woosh.Token(woosh.DEDENT, ' ', 216, 0, 216, 4),
woosh.Token(woosh.DEDENT, '', 216, 4, 216, 4),
woosh.Token(woosh.NAME, 'else', 216, 4, 216, 8),
woosh.Token(woosh.OP, ':', 216, 8, 216, 9),
woosh.Token(woosh.NEWLINE, '\r\n', 216, 9, 217, 0),
woosh.Token(woosh.INDENT, ' ', 217, 0, 217, 8),
woosh.Token(woosh.NAME, 'raise', 217, 8, 217, 13),
woosh.Token(woosh.NAME, 'ValueError', 217, 14, 217, 24),
woosh.Token(woosh.OP, '(', 217, 24, 217, 25),
woosh.Token(woosh.STRING, '"overflow in number field"', 217, 25, 217, 51),
woosh.Token(woosh.OP, ')', 217, 51, 217, 52),
woosh.Token(woosh.NEWLINE, '\r\n', 217, 52, 218, 0),
woosh.Token(woosh.DEDENT, ' ', 219, 0, 219, 4),
woosh.Token(woosh.NAME, 'return', 219, 4, 219, 10),
woosh.Token(woosh.NAME, 's', 219, 11, 219, 12),
woosh.Token(woosh.NEWLINE, '\r\n', 219, 12, 220, 0),
woosh.Token(woosh.DEDENT, '', 221, 0, 221, 0),
woosh.Token(woosh.NAME, 'def', 221, 0, 221, 3),
woosh.Token(woosh.NAME, 'calc_chksums', 221, 4, 221, 16),
woosh.Token(woosh.OP, '(', 221, 16, 221, 17),
woosh.Token(woosh.NAME, 'buf', 221, 17, 221, 20),
woosh.Token(woosh.OP, ')', 221, 20, 221, 21),
woosh.Token(woosh.OP, ':', 221, 21, 221, 22),
woosh.Token(woosh.NEWLINE, '\r\n', 221, 22, 222, 0),
woosh.Token(woosh.INDENT, ' ', 222, 0, 222, 4),
woosh.Token(woosh.STRING, '"""Calculate the checksum for a member\'s header by summing up all\r\n characters except for the chksum field which is treated as if\r\n it was filled with spaces. According to the GNU tar sources,\r\n some tars (Sun and NeXT) calculate chksum with signed char,\r\n which will be different if there are chars in the buffer with\r\n the high bit set. So we calculate two checksums, unsigned and\r\n signed.\r\n """', 222, 4, 229, 7),
woosh.Token(woosh.NEWLINE, '\r\n', 229, 7, 230, 0),
woosh.Token(woosh.NAME, 'unsigned_chksum', 230, 4, 230, 19),
woosh.Token(woosh.OP, '=', 230, 20, 230, 21),
woosh.Token(woosh.NUMBER, '256', 230, 22, 230, 25),
woosh.Token(woosh.OP, '+', 230, 26, 230, 27),
woosh.Token(woosh.NAME, 'sum', 230, 28, 230, 31),
woosh.Token(woosh.OP, '(', 230, 31, 230, 32),
woosh.Token(woosh.NAME, 'struct', 230, 32, 230, 38),
woosh.Token(woosh.OP, '.', 230, 38, 230, 39),
woosh.Token(woosh.NAME, 'unpack_from', 230, 39, 230, 50),
woosh.Token(woosh.OP, '(', 230, 50, 230, 51),
woosh.Token(woosh.STRING, '"148B8x356B"', 230, 51, 230, 63),
woosh.Token(woosh.OP, ',', 230, 63, 230, 64),
woosh.Token(woosh.NAME, 'buf', 230, 65, 230, 68),
woosh.Token(woosh.OP, ')', 230, 68, 230, 69),
woosh.Token(woosh.OP, ')', 230, 69, 230, 70),
woosh.Token(woosh.NEWLINE, '\r\n', 230, 70, 231, 0),
woosh.Token(woosh.NAME, 'signed_chksum', 231, 4, 231, 17),
woosh.Token(woosh.OP, '=', 231, 18, 231, 19),
woosh.Token(woosh.NUMBER, '256', 231, 20, 231, 23),
woosh.Token(woosh.OP, '+', 231, 24, 231, 25),
woosh.Token(woosh.NAME, 'sum', 231, 26, 231, 29),
woosh.Token(woosh.OP, '(', 231, 29, 231, 30),
woosh.Token(woosh.NAME, 'struct', 231, 30, 231, 36),
woosh.Token(woosh.OP, '.', 231, 36, 231, 37),
woosh.Token(woosh.NAME, 'unpack_from', 231, 37, 231, 48),
woosh.Token(woosh.OP, '(', 231, 48, 231, 49),
woosh.Token(woosh.STRING, '"148b8x356b"', 231, 49, 231, 61),
woosh.Token(woosh.OP, ',', 231, 61, 231, 62),
woosh.Token(woosh.NAME, 'buf', 231, 63, 231, 66),
woosh.Token(woosh.OP, ')', 231, 66, 231, 67),
woosh.Token(woosh.OP, ')', 231, 67, 231, 68),
woosh.Token(woosh.NEWLINE, '\r\n', 231, 68, 232, 0),
woosh.Token(woosh.NAME, 'return', 232, 4, 232, 10),
woosh.Token(woosh.NAME, 'unsigned_chksum', 232, 11, 232, 26),
woosh.Token(woosh.OP, ',', 232, 26, 232, 27),
woosh.Token(woosh.NAME, 'signed_chksum', 232, 28, 232, 41),
woosh.Token(woosh.NEWLINE, '\r\n', 232, 41, 233, 0),
woosh.Token(woosh.DEDENT, '', 234, 0, 234, 0),
woosh.Token(woosh.NAME, 'def', 234, 0, 234, 3),
woosh.Token(woosh.NAME, 'copyfileobj', 234, 4, 234, 15),
woosh.Token(woosh.OP, '(', 234, 15, 234, 16),
woosh.Token(woosh.NAME, 'src', 234, 16, 234, 19),
woosh.Token(woosh.OP, ',', 234, 19, 234, 20),
woosh.Token(woosh.NAME, 'dst', 234, 21, 234, 24),
woosh.Token(woosh.OP, ',', 234, 24, 234, 25),
woosh.Token(woosh.NAME, 'length', 234, 26, 234, 32),
woosh.Token(woosh.OP, '=', 234, 32, 234, 33),
woosh.Token(woosh.NAME, 'None', 234, 33, 234, 37),
woosh.Token(woosh.OP, ',', 234, 37, 234, 38),
woosh.Token(woosh.NAME, 'exception', 234, 39, 234, 48),
woosh.Token(woosh.OP, '=', 234, 48, 234, 49),
woosh.Token(woosh.NAME, 'OSError', 234, 49, 234, 56),
woosh.Token(woosh.OP, ',', 234, 56, 234, 57),
woosh.Token(woosh.NAME, 'bufsize', 234, 58, 234, 65),
woosh.Token(woosh.OP, '=', 234, 65, 234, 66),
woosh.Token(woosh.NAME, 'None', 234, 66, 234, 70),
woosh.Token(woosh.OP, ')', 234, 70, 234, 71),
woosh.Token(woosh.OP, ':', 234, 71, 234, 72),
woosh.Token(woosh.NEWLINE, '\r\n', 234, 72, 235, 0),
woosh.Token(woosh.INDENT, ' ', 235, 0, 235, 4),
woosh.Token(woosh.STRING, '"""Copy length bytes from fileobj src to fileobj dst.\r\n If length is None, copy the entire content.\r\n """', 235, 4, 237, 7),
woosh.Token(woosh.NEWLINE, '\r\n', 237, 7, 238, 0),
woosh.Token(woosh.NAME, 'bufsize', 238, 4, 238, 11),
woosh.Token(woosh.OP, '=', 238, 12, 238, 13),
woosh.Token(woosh.NAME, 'bufsize', 238, 14, 238, 21),
woosh.Token(woosh.NAME, 'or', 238, 22, 238, 24),
woosh.Token(woosh.NUMBER, '16', 238, 25, 238, 27),
woosh.Token(woosh.OP, '*', 238, 28, 238, 29),
woosh.Token(woosh.NUMBER, '1024', 238, 30, 238, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 238, 34, 239, 0),
woosh.Token(woosh.NAME, 'if', 239, 4, 239, 6),
woosh.Token(woosh.NAME, 'length', 239, 7, 239, 13),
woosh.Token(woosh.OP, '==', 239, 14, 239, 16),
woosh.Token(woosh.NUMBER, '0', 239, 17, 239, 18),
woosh.Token(woosh.OP, ':', 239, 18, 239, 19),
woosh.Token(woosh.NEWLINE, '\r\n', 239, 19, 240, 0),
woosh.Token(woosh.INDENT, ' ', 240, 0, 240, 8),
woosh.Token(woosh.NAME, 'return', 240, 8, 240, 14),
woosh.Token(woosh.NEWLINE, '\r\n', 240, 14, 241, 0),
woosh.Token(woosh.DEDENT, ' ', 241, 0, 241, 4),
woosh.Token(woosh.NAME, 'if', 241, 4, 241, 6),
woosh.Token(woosh.NAME, 'length', 241, 7, 241, 13),
woosh.Token(woosh.NAME, 'is', 241, 14, 241, 16),
woosh.Token(woosh.NAME, 'None', 241, 17, 241, 21),
woosh.Token(woosh.OP, ':', 241, 21, 241, 22),
woosh.Token(woosh.NEWLINE, '\r\n', 241, 22, 242, 0),
woosh.Token(woosh.INDENT, ' ', 242, 0, 242, 8),
woosh.Token(woosh.NAME, 'shutil', 242, 8, 242, 14),
woosh.Token(woosh.OP, '.', 242, 14, 242, 15),
woosh.Token(woosh.NAME, 'copyfileobj', 242, 15, 242, 26),
woosh.Token(woosh.OP, '(', 242, 26, 242, 27),
woosh.Token(woosh.NAME, 'src', 242, 27, 242, 30),
woosh.Token(woosh.OP, ',', 242, 30, 242, 31),
woosh.Token(woosh.NAME, 'dst', 242, 32, 242, 35),
woosh.Token(woosh.OP, ',', 242, 35, 242, 36),
woosh.Token(woosh.NAME, 'bufsize', 242, 37, 242, 44),
woosh.Token(woosh.OP, ')', 242, 44, 242, 45),
woosh.Token(woosh.NEWLINE, '\r\n', 242, 45, 243, 0),
woosh.Token(woosh.NAME, 'return', 243, 8, 243, 14),
woosh.Token(woosh.NEWLINE, '\r\n', 243, 14, 244, 0),
woosh.Token(woosh.DEDENT, ' ', 245, 0, 245, 4),
woosh.Token(woosh.NAME, 'blocks', 245, 4, 245, 10),
woosh.Token(woosh.OP, ',', 245, 10, 245, 11),
woosh.Token(woosh.NAME, 'remainder', 245, 12, 245, 21),
woosh.Token(woosh.OP, '=', 245, 22, 245, 23),
woosh.Token(woosh.NAME, 'divmod', 245, 24, 245, 30),
woosh.Token(woosh.OP, '(', 245, 30, 245, 31),
woosh.Token(woosh.NAME, 'length', 245, 31, 245, 37),
woosh.Token(woosh.OP, ',', 245, 37, 245, 38),
woosh.Token(woosh.NAME, 'bufsize', 245, 39, 245, 46),
woosh.Token(woosh.OP, ')', 245, 46, 245, 47),
woosh.Token(woosh.NEWLINE, '\r\n', 245, 47, 246, 0),
woosh.Token(woosh.NAME, 'for', 246, 4, 246, 7),
woosh.Token(woosh.NAME, 'b', 246, 8, 246, 9),
woosh.Token(woosh.NAME, 'in', 246, 10, 246, 12),
woosh.Token(woosh.NAME, 'range', 246, 13, 246, 18),
woosh.Token(woosh.OP, '(', 246, 18, 246, 19),
woosh.Token(woosh.NAME, 'blocks', 246, 19, 246, 25),
woosh.Token(woosh.OP, ')', 246, 25, 246, 26),
woosh.Token(woosh.OP, ':', 246, 26, 246, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 246, 27, 247, 0),
woosh.Token(woosh.INDENT, ' ', 247, 0, 247, 8),
woosh.Token(woosh.NAME, 'buf', 247, 8, 247, 11),
woosh.Token(woosh.OP, '=', 247, 12, 247, 13),
woosh.Token(woosh.NAME, 'src', 247, 14, 247, 17),
woosh.Token(woosh.OP, '.', 247, 17, 247, 18),
woosh.Token(woosh.NAME, 'read', 247, 18, 247, 22),
woosh.Token(woosh.OP, '(', 247, 22, 247, 23),
woosh.Token(woosh.NAME, 'bufsize', 247, 23, 247, 30),
woosh.Token(woosh.OP, ')', 247, 30, 247, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 247, 31, 248, 0),
woosh.Token(woosh.NAME, 'if', 248, 8, 248, 10),
woosh.Token(woosh.NAME, 'len', 248, 11, 248, 14),
woosh.Token(woosh.OP, '(', 248, 14, 248, 15),
woosh.Token(woosh.NAME, 'buf', 248, 15, 248, 18),
woosh.Token(woosh.OP, ')', 248, 18, 248, 19),
woosh.Token(woosh.OP, '<', 248, 20, 248, 21),
woosh.Token(woosh.NAME, 'bufsize', 248, 22, 248, 29),
woosh.Token(woosh.OP, ':', 248, 29, 248, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 248, 30, 249, 0),
woosh.Token(woosh.INDENT, ' ', 249, 0, 249, 12),
woosh.Token(woosh.NAME, 'raise', 249, 12, 249, 17),
woosh.Token(woosh.NAME, 'exception', 249, 18, 249, 27),
woosh.Token(woosh.OP, '(', 249, 27, 249, 28),
woosh.Token(woosh.STRING, '"unexpected end of data"', 249, 28, 249, 52),
woosh.Token(woosh.OP, ')', 249, 52, 249, 53),
woosh.Token(woosh.NEWLINE, '\r\n', 249, 53, 250, 0),
woosh.Token(woosh.DEDENT, ' ', 250, 0, 250, 8),
woosh.Token(woosh.NAME, 'dst', 250, 8, 250, 11),
woosh.Token(woosh.OP, '.', 250, 11, 250, 12),
woosh.Token(woosh.NAME, 'write', 250, 12, 250, 17),
woosh.Token(woosh.OP, '(', 250, 17, 250, 18),
woosh.Token(woosh.NAME, 'buf', 250, 18, 250, 21),
woosh.Token(woosh.OP, ')', 250, 21, 250, 22),
woosh.Token(woosh.NEWLINE, '\r\n', 250, 22, 251, 0),
woosh.Token(woosh.DEDENT, ' ', 252, 0, 252, 4),
woosh.Token(woosh.NAME, 'if', 252, 4, 252, 6),
woosh.Token(woosh.NAME, 'remainder', 252, 7, 252, 16),
woosh.Token(woosh.OP, '!=', 252, 17, 252, 19),
woosh.Token(woosh.NUMBER, '0', 252, 20, 252, 21),
woosh.Token(woosh.OP, ':', 252, 21, 252, 22),
woosh.Token(woosh.NEWLINE, '\r\n', 252, 22, 253, 0),
woosh.Token(woosh.INDENT, ' ', 253, 0, 253, 8),
woosh.Token(woosh.NAME, 'buf', 253, 8, 253, 11),
woosh.Token(woosh.OP, '=', 253, 12, 253, 13),
woosh.Token(woosh.NAME, 'src', 253, 14, 253, 17),
woosh.Token(woosh.OP, '.', 253, 17, 253, 18),
woosh.Token(woosh.NAME, 'read', 253, 18, 253, 22),
woosh.Token(woosh.OP, '(', 253, 22, 253, 23),
woosh.Token(woosh.NAME, 'remainder', 253, 23, 253, 32),
woosh.Token(woosh.OP, ')', 253, 32, 253, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 253, 33, 254, 0),
woosh.Token(woosh.NAME, 'if', 254, 8, 254, 10),
woosh.Token(woosh.NAME, 'len', 254, 11, 254, 14),
woosh.Token(woosh.OP, '(', 254, 14, 254, 15),
woosh.Token(woosh.NAME, 'buf', 254, 15, 254, 18),
woosh.Token(woosh.OP, ')', 254, 18, 254, 19),
woosh.Token(woosh.OP, '<', 254, 20, 254, 21),
woosh.Token(woosh.NAME, 'remainder', 254, 22, 254, 31),
woosh.Token(woosh.OP, ':', 254, 31, 254, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 254, 32, 255, 0),
woosh.Token(woosh.INDENT, ' ', 255, 0, 255, 12),
woosh.Token(woosh.NAME, 'raise', 255, 12, 255, 17),
woosh.Token(woosh.NAME, 'exception', 255, 18, 255, 27),
woosh.Token(woosh.OP, '(', 255, 27, 255, 28),
woosh.Token(woosh.STRING, '"unexpected end of data"', 255, 28, 255, 52),
woosh.Token(woosh.OP, ')', 255, 52, 255, 53),
woosh.Token(woosh.NEWLINE, '\r\n', 255, 53, 256, 0),
woosh.Token(woosh.DEDENT, ' ', 256, 0, 256, 8),
woosh.Token(woosh.NAME, 'dst', 256, 8, 256, 11),
woosh.Token(woosh.OP, '.', 256, 11, 256, 12),
woosh.Token(woosh.NAME, 'write', 256, 12, 256, 17),
woosh.Token(woosh.OP, '(', 256, 17, 256, 18),
woosh.Token(woosh.NAME, 'buf', 256, 18, 256, 21),
woosh.Token(woosh.OP, ')', 256, 21, 256, 22),
woosh.Token(woosh.NEWLINE, '\r\n', 256, 22, 257, 0),
woosh.Token(woosh.DEDENT, ' ', 257, 0, 257, 4),
woosh.Token(woosh.NAME, 'return', 257, 4, 257, 10),
woosh.Token(woosh.NEWLINE, '\r\n', 257, 10, 258, 0),
woosh.Token(woosh.DEDENT, '', 259, 0, 259, 0),
woosh.Token(woosh.NAME, 'def', 259, 0, 259, 3),
woosh.Token(woosh.NAME, '_safe_print', 259, 4, 259, 15),
woosh.Token(woosh.OP, '(', 259, 15, 259, 16),
woosh.Token(woosh.NAME, 's', 259, 16, 259, 17),
woosh.Token(woosh.OP, ')', 259, 17, 259, 18),
woosh.Token(woosh.OP, ':', 259, 18, 259, 19),
woosh.Token(woosh.NEWLINE, '\r\n', 259, 19, 260, 0),
woosh.Token(woosh.INDENT, ' ', 260, 0, 260, 4),
woosh.Token(woosh.NAME, 'encoding', 260, 4, 260, 12),
woosh.Token(woosh.OP, '=', 260, 13, 260, 14),
woosh.Token(woosh.NAME, 'getattr', 260, 15, 260, 22),
woosh.Token(woosh.OP, '(', 260, 22, 260, 23),
woosh.Token(woosh.NAME, 'sys', 260, 23, 260, 26),
woosh.Token(woosh.OP, '.', 260, 26, 260, 27),
woosh.Token(woosh.NAME, 'stdout', 260, 27, 260, 33),
woosh.Token(woosh.OP, ',', 260, 33, 260, 34),
woosh.Token(woosh.STRING, "'encoding'", 260, 35, 260, 45),
woosh.Token(woosh.OP, ',', 260, 45, 260, 46),
woosh.Token(woosh.NAME, 'None', 260, 47, 260, 51),
woosh.Token(woosh.OP, ')', 260, 51, 260, 52),
woosh.Token(woosh.NEWLINE, '\r\n', 260, 52, 261, 0),
woosh.Token(woosh.NAME, 'if', 261, 4, 261, 6),
woosh.Token(woosh.NAME, 'encoding', 261, 7, 261, 15),
woosh.Token(woosh.NAME, 'is', 261, 16, 261, 18),
woosh.Token(woosh.NAME, 'not', 261, 19, 261, 22),
woosh.Token(woosh.NAME, 'None', 261, 23, 261, 27),
woosh.Token(woosh.OP, ':', 261, 27, 261, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 261, 28, 262, 0),
woosh.Token(woosh.INDENT, ' ', 262, 0, 262, 8),
woosh.Token(woosh.NAME, 's', 262, 8, 262, 9),
woosh.Token(woosh.OP, '=', 262, 10, 262, 11),
woosh.Token(woosh.NAME, 's', 262, 12, 262, 13),
woosh.Token(woosh.OP, '.', 262, 13, 262, 14),
woosh.Token(woosh.NAME, 'encode', 262, 14, 262, 20),
woosh.Token(woosh.OP, '(', 262, 20, 262, 21),
woosh.Token(woosh.NAME, 'encoding', 262, 21, 262, 29),
woosh.Token(woosh.OP, ',', 262, 29, 262, 30),
woosh.Token(woosh.STRING, "'backslashreplace'", 262, 31, 262, 49),
woosh.Token(woosh.OP, ')', 262, 49, 262, 50),
woosh.Token(woosh.OP, '.', 262, 50, 262, 51),
woosh.Token(woosh.NAME, 'decode', 262, 51, 262, 57),
woosh.Token(woosh.OP, '(', 262, 57, 262, 58),
woosh.Token(woosh.NAME, 'encoding', 262, 58, 262, 66),
woosh.Token(woosh.OP, ')', 262, 66, 262, 67),
woosh.Token(woosh.NEWLINE, '\r\n', 262, 67, 263, 0),
woosh.Token(woosh.DEDENT, ' ', 263, 0, 263, 4),
woosh.Token(woosh.NAME, 'print', 263, 4, 263, 9),
woosh.Token(woosh.OP, '(', 263, 9, 263, 10),
woosh.Token(woosh.NAME, 's', 263, 10, 263, 11),
woosh.Token(woosh.OP, ',', 263, 11, 263, 12),
woosh.Token(woosh.NAME, 'end', 263, 13, 263, 16),
woosh.Token(woosh.OP, '=', 263, 16, 263, 17),
woosh.Token(woosh.STRING, "' '", 263, 17, 263, 20),
woosh.Token(woosh.OP, ')', 263, 20, 263, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 263, 21, 264, 0),
woosh.Token(woosh.DEDENT, '', 266, 0, 266, 0),
woosh.Token(woosh.NAME, 'class', 266, 0, 266, 5),
woosh.Token(woosh.NAME, 'TarError', 266, 6, 266, 14),
woosh.Token(woosh.OP, '(', 266, 14, 266, 15),
woosh.Token(woosh.NAME, 'Exception', 266, 15, 266, 24),
woosh.Token(woosh.OP, ')', 266, 24, 266, 25),
woosh.Token(woosh.OP, ':', 266, 25, 266, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 266, 26, 267, 0),
woosh.Token(woosh.INDENT, ' ', 267, 0, 267, 4),
woosh.Token(woosh.STRING, '"""Base exception."""', 267, 4, 267, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 267, 25, 268, 0),
woosh.Token(woosh.NAME, 'pass', 268, 4, 268, 8),
woosh.Token(woosh.NEWLINE, '\r\n', 268, 8, 269, 0),
woosh.Token(woosh.DEDENT, '', 269, 0, 269, 0),
woosh.Token(woosh.NAME, 'class', 269, 0, 269, 5),
woosh.Token(woosh.NAME, 'ExtractError', 269, 6, 269, 18),
woosh.Token(woosh.OP, '(', 269, 18, 269, 19),
woosh.Token(woosh.NAME, 'TarError', 269, 19, 269, 27),
woosh.Token(woosh.OP, ')', 269, 27, 269, 28),
woosh.Token(woosh.OP, ':', 269, 28, 269, 29),
woosh.Token(woosh.NEWLINE, '\r\n', 269, 29, 270, 0),
woosh.Token(woosh.INDENT, ' ', 270, 0, 270, 4),
woosh.Token(woosh.STRING, '"""General exception for extract errors."""', 270, 4, 270, 47),
woosh.Token(woosh.NEWLINE, '\r\n', 270, 47, 271, 0),
woosh.Token(woosh.NAME, 'pass', 271, 4, 271, 8),
woosh.Token(woosh.NEWLINE, '\r\n', 271, 8, 272, 0),
woosh.Token(woosh.DEDENT, '', 272, 0, 272, 0),
woosh.Token(woosh.NAME, 'class', 272, 0, 272, 5),
woosh.Token(woosh.NAME, 'ReadError', 272, 6, 272, 15),
woosh.Token(woosh.OP, '(', 272, 15, 272, 16),
woosh.Token(woosh.NAME, 'TarError', 272, 16, 272, 24),
woosh.Token(woosh.OP, ')', 272, 24, 272, 25),
woosh.Token(woosh.OP, ':', 272, 25, 272, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 272, 26, 273, 0),
woosh.Token(woosh.INDENT, ' ', 273, 0, 273, 4),
woosh.Token(woosh.STRING, '"""Exception for unreadable tar archives."""', 273, 4, 273, 48),
woosh.Token(woosh.NEWLINE, '\r\n', 273, 48, 274, 0),
woosh.Token(woosh.NAME, 'pass', 274, 4, 274, 8),
woosh.Token(woosh.NEWLINE, '\r\n', 274, 8, 275, 0),
woosh.Token(woosh.DEDENT, '', 275, 0, 275, 0),
woosh.Token(woosh.NAME, 'class', 275, 0, 275, 5),
woosh.Token(woosh.NAME, 'CompressionError', 275, 6, 275, 22),
woosh.Token(woosh.OP, '(', 275, 22, 275, 23),
woosh.Token(woosh.NAME, 'TarError', 275, 23, 275, 31),
woosh.Token(woosh.OP, ')', 275, 31, 275, 32),
woosh.Token(woosh.OP, ':', 275, 32, 275, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 275, 33, 276, 0),
woosh.Token(woosh.INDENT, ' ', 276, 0, 276, 4),
woosh.Token(woosh.STRING, '"""Exception for unavailable compression methods."""', 276, 4, 276, 56),
woosh.Token(woosh.NEWLINE, '\r\n', 276, 56, 277, 0),
woosh.Token(woosh.NAME, 'pass', 277, 4, 277, 8),
woosh.Token(woosh.NEWLINE, '\r\n', 277, 8, 278, 0),
woosh.Token(woosh.DEDENT, '', 278, 0, 278, 0),
woosh.Token(woosh.NAME, 'class', 278, 0, 278, 5),
woosh.Token(woosh.NAME, 'StreamError', 278, 6, 278, 17),
woosh.Token(woosh.OP, '(', 278, 17, 278, 18),
woosh.Token(woosh.NAME, 'TarError', 278, 18, 278, 26),
woosh.Token(woosh.OP, ')', 278, 26, 278, 27),
woosh.Token(woosh.OP, ':', 278, 27, 278, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 278, 28, 279, 0),
woosh.Token(woosh.INDENT, ' ', 279, 0, 279, 4),
woosh.Token(woosh.STRING, '"""Exception for unsupported operations on stream-like TarFiles."""', 279, 4, 279, 71),
woosh.Token(woosh.NEWLINE, '\r\n', 279, 71, 280, 0),
woosh.Token(woosh.NAME, 'pass', 280, 4, 280, 8),
woosh.Token(woosh.NEWLINE, '\r\n', 280, 8, 281, 0),
woosh.Token(woosh.DEDENT, '', 281, 0, 281, 0),
woosh.Token(woosh.NAME, 'class', 281, 0, 281, 5),
woosh.Token(woosh.NAME, 'HeaderError', 281, 6, 281, 17),
woosh.Token(woosh.OP, '(', 281, 17, 281, 18),
woosh.Token(woosh.NAME, 'TarError', 281, 18, 281, 26),
woosh.Token(woosh.OP, ')', 281, 26, 281, 27),
woosh.Token(woosh.OP, ':', 281, 27, 281, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 281, 28, 282, 0),
woosh.Token(woosh.INDENT, ' ', 282, 0, 282, 4),
woosh.Token(woosh.STRING, '"""Base exception for header errors."""', 282, 4, 282, 43),
woosh.Token(woosh.NEWLINE, '\r\n', 282, 43, 283, 0),
woosh.Token(woosh.NAME, 'pass', 283, 4, 283, 8),
woosh.Token(woosh.NEWLINE, '\r\n', 283, 8, 284, 0),
woosh.Token(woosh.DEDENT, '', 284, 0, 284, 0),
woosh.Token(woosh.NAME, 'class', 284, 0, 284, 5),
woosh.Token(woosh.NAME, 'EmptyHeaderError', 284, 6, 284, 22),
woosh.Token(woosh.OP, '(', 284, 22, 284, 23),
woosh.Token(woosh.NAME, 'HeaderError', 284, 23, 284, 34),
woosh.Token(woosh.OP, ')', 284, 34, 284, 35),
woosh.Token(woosh.OP, ':', 284, 35, 284, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 284, 36, 285, 0),
woosh.Token(woosh.INDENT, ' ', 285, 0, 285, 4),
woosh.Token(woosh.STRING, '"""Exception for empty headers."""', 285, 4, 285, 38),
woosh.Token(woosh.NEWLINE, '\r\n', 285, 38, 286, 0),
woosh.Token(woosh.NAME, 'pass', 286, 4, 286, 8),
woosh.Token(woosh.NEWLINE, '\r\n', 286, 8, 287, 0),
woosh.Token(woosh.DEDENT, '', 287, 0, 287, 0),
woosh.Token(woosh.NAME, 'class', 287, 0, 287, 5),
woosh.Token(woosh.NAME, 'TruncatedHeaderError', 287, 6, 287, 26),
woosh.Token(woosh.OP, '(', 287, 26, 287, 27),
woosh.Token(woosh.NAME, 'HeaderError', 287, 27, 287, 38),
woosh.Token(woosh.OP, ')', 287, 38, 287, 39),
woosh.Token(woosh.OP, ':', 287, 39, 287, 40),
woosh.Token(woosh.NEWLINE, '\r\n', 287, 40, 288, 0),
woosh.Token(woosh.INDENT, ' ', 288, 0, 288, 4),
woosh.Token(woosh.STRING, '"""Exception for truncated headers."""', 288, 4, 288, 42),
woosh.Token(woosh.NEWLINE, '\r\n', 288, 42, 289, 0),
woosh.Token(woosh.NAME, 'pass', 289, 4, 289, 8),
woosh.Token(woosh.NEWLINE, '\r\n', 289, 8, 290, 0),
woosh.Token(woosh.DEDENT, '', 290, 0, 290, 0),
woosh.Token(woosh.NAME, 'class', 290, 0, 290, 5),
woosh.Token(woosh.NAME, 'EOFHeaderError', 290, 6, 290, 20),
woosh.Token(woosh.OP, '(', 290, 20, 290, 21),
woosh.Token(woosh.NAME, 'HeaderError', 290, 21, 290, 32),
woosh.Token(woosh.OP, ')', 290, 32, 290, 33),
woosh.Token(woosh.OP, ':', 290, 33, 290, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 290, 34, 291, 0),
woosh.Token(woosh.INDENT, ' ', 291, 0, 291, 4),
woosh.Token(woosh.STRING, '"""Exception for end of file headers."""', 291, 4, 291, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 291, 44, 292, 0),
woosh.Token(woosh.NAME, 'pass', 292, 4, 292, 8),
woosh.Token(woosh.NEWLINE, '\r\n', 292, 8, 293, 0),
woosh.Token(woosh.DEDENT, '', 293, 0, 293, 0),
woosh.Token(woosh.NAME, 'class', 293, 0, 293, 5),
woosh.Token(woosh.NAME, 'InvalidHeaderError', 293, 6, 293, 24),
woosh.Token(woosh.OP, '(', 293, 24, 293, 25),
woosh.Token(woosh.NAME, 'HeaderError', 293, 25, 293, 36),
woosh.Token(woosh.OP, ')', 293, 36, 293, 37),
woosh.Token(woosh.OP, ':', 293, 37, 293, 38),
woosh.Token(woosh.NEWLINE, '\r\n', 293, 38, 294, 0),
woosh.Token(woosh.INDENT, ' ', 294, 0, 294, 4),
woosh.Token(woosh.STRING, '"""Exception for invalid headers."""', 294, 4, 294, 40),
woosh.Token(woosh.NEWLINE, '\r\n', 294, 40, 295, 0),
woosh.Token(woosh.NAME, 'pass', 295, 4, 295, 8),
woosh.Token(woosh.NEWLINE, '\r\n', 295, 8, 296, 0),
woosh.Token(woosh.DEDENT, '', 296, 0, 296, 0),
woosh.Token(woosh.NAME, 'class', 296, 0, 296, 5),
woosh.Token(woosh.NAME, 'SubsequentHeaderError', 296, 6, 296, 27),
woosh.Token(woosh.OP, '(', 296, 27, 296, 28),
woosh.Token(woosh.NAME, 'HeaderError', 296, 28, 296, 39),
woosh.Token(woosh.OP, ')', 296, 39, 296, 40),
woosh.Token(woosh.OP, ':', 296, 40, 296, 41),
woosh.Token(woosh.NEWLINE, '\r\n', 296, 41, 297, 0),
woosh.Token(woosh.INDENT, ' ', 297, 0, 297, 4),
woosh.Token(woosh.STRING, '"""Exception for missing and invalid extended headers."""', 297, 4, 297, 61),
woosh.Token(woosh.NEWLINE, '\r\n', 297, 61, 298, 0),
woosh.Token(woosh.NAME, 'pass', 298, 4, 298, 8),
woosh.Token(woosh.NEWLINE, '\r\n', 298, 8, 299, 0),
woosh.Token(woosh.COMMENT, '#---------------------------', 300, 0, 300, 28),
woosh.Token(woosh.COMMENT, '# internal stream interface', 301, 0, 301, 27),
woosh.Token(woosh.COMMENT, '#---------------------------', 302, 0, 302, 28),
woosh.Token(woosh.DEDENT, '', 303, 0, 303, 0),
woosh.Token(woosh.NAME, 'class', 303, 0, 303, 5),
woosh.Token(woosh.NAME, '_LowLevelFile', 303, 6, 303, 19),
woosh.Token(woosh.OP, ':', 303, 19, 303, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 303, 20, 304, 0),
woosh.Token(woosh.INDENT, ' ', 304, 0, 304, 4),
woosh.Token(woosh.STRING, '"""Low-level file object. Supports reading and writing.\r\n It is used instead of a regular file object for streaming\r\n access.\r\n """', 304, 4, 307, 7),
woosh.Token(woosh.NEWLINE, '\r\n', 307, 7, 308, 0),
woosh.Token(woosh.NAME, 'def', 309, 4, 309, 7),
woosh.Token(woosh.NAME, '__init__', 309, 8, 309, 16),
woosh.Token(woosh.OP, '(', 309, 16, 309, 17),
woosh.Token(woosh.NAME, 'self', 309, 17, 309, 21),
woosh.Token(woosh.OP, ',', 309, 21, 309, 22),
woosh.Token(woosh.NAME, 'name', 309, 23, 309, 27),
woosh.Token(woosh.OP, ',', 309, 27, 309, 28),
woosh.Token(woosh.NAME, 'mode', 309, 29, 309, 33),
woosh.Token(woosh.OP, ')', 309, 33, 309, 34),
woosh.Token(woosh.OP, ':', 309, 34, 309, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 309, 35, 310, 0),
woosh.Token(woosh.INDENT, ' ', 310, 0, 310, 8),
woosh.Token(woosh.NAME, 'mode', 310, 8, 310, 12),
woosh.Token(woosh.OP, '=', 310, 13, 310, 14),
woosh.Token(woosh.OP, '{', 310, 15, 310, 16),
woosh.Token(woosh.STRING, '"r"', 311, 12, 311, 15),
woosh.Token(woosh.OP, ':', 311, 15, 311, 16),
woosh.Token(woosh.NAME, 'os', 311, 17, 311, 19),
woosh.Token(woosh.OP, '.', 311, 19, 311, 20),
woosh.Token(woosh.NAME, 'O_RDONLY', 311, 20, 311, 28),
woosh.Token(woosh.OP, ',', 311, 28, 311, 29),
woosh.Token(woosh.STRING, '"w"', 312, 12, 312, 15),
woosh.Token(woosh.OP, ':', 312, 15, 312, 16),
woosh.Token(woosh.NAME, 'os', 312, 17, 312, 19),
woosh.Token(woosh.OP, '.', 312, 19, 312, 20),
woosh.Token(woosh.NAME, 'O_WRONLY', 312, 20, 312, 28),
woosh.Token(woosh.OP, '|', 312, 29, 312, 30),
woosh.Token(woosh.NAME, 'os', 312, 31, 312, 33),
woosh.Token(woosh.OP, '.', 312, 33, 312, 34),
woosh.Token(woosh.NAME, 'O_CREAT', 312, 34, 312, 41),
woosh.Token(woosh.OP, '|', 312, 42, 312, 43),
woosh.Token(woosh.NAME, 'os', 312, 44, 312, 46),
woosh.Token(woosh.OP, '.', 312, 46, 312, 47),
woosh.Token(woosh.NAME, 'O_TRUNC', 312, 47, 312, 54),
woosh.Token(woosh.OP, ',', 312, 54, 312, 55),
woosh.Token(woosh.OP, '}', 313, 8, 313, 9),
woosh.Token(woosh.OP, '[', 313, 9, 313, 10),
woosh.Token(woosh.NAME, 'mode', 313, 10, 313, 14),
woosh.Token(woosh.OP, ']', 313, 14, 313, 15),
woosh.Token(woosh.NEWLINE, '\r\n', 313, 15, 314, 0),
woosh.Token(woosh.NAME, 'if', 314, 8, 314, 10),
woosh.Token(woosh.NAME, 'hasattr', 314, 11, 314, 18),
woosh.Token(woosh.OP, '(', 314, 18, 314, 19),
woosh.Token(woosh.NAME, 'os', 314, 19, 314, 21),
woosh.Token(woosh.OP, ',', 314, 21, 314, 22),
woosh.Token(woosh.STRING, '"O_BINARY"', 314, 23, 314, 33),
woosh.Token(woosh.OP, ')', 314, 33, 314, 34),
woosh.Token(woosh.OP, ':', 314, 34, 314, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 314, 35, 315, 0),
woosh.Token(woosh.INDENT, ' ', 315, 0, 315, 12),
woosh.Token(woosh.NAME, 'mode', 315, 12, 315, 16),
woosh.Token(woosh.OP, '|=', 315, 17, 315, 19),
woosh.Token(woosh.NAME, 'os', 315, 20, 315, 22),
woosh.Token(woosh.OP, '.', 315, 22, 315, 23),
woosh.Token(woosh.NAME, 'O_BINARY', 315, 23, 315, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 315, 31, 316, 0),
woosh.Token(woosh.DEDENT, ' ', 316, 0, 316, 8),
woosh.Token(woosh.NAME, 'self', 316, 8, 316, 12),
woosh.Token(woosh.OP, '.', 316, 12, 316, 13),
woosh.Token(woosh.NAME, 'fd', 316, 13, 316, 15),
woosh.Token(woosh.OP, '=', 316, 16, 316, 17),
woosh.Token(woosh.NAME, 'os', 316, 18, 316, 20),
woosh.Token(woosh.OP, '.', 316, 20, 316, 21),
woosh.Token(woosh.NAME, 'open', 316, 21, 316, 25),
woosh.Token(woosh.OP, '(', 316, 25, 316, 26),
woosh.Token(woosh.NAME, 'name', 316, 26, 316, 30),
woosh.Token(woosh.OP, ',', 316, 30, 316, 31),
woosh.Token(woosh.NAME, 'mode', 316, 32, 316, 36),
woosh.Token(woosh.OP, ',', 316, 36, 316, 37),
woosh.Token(woosh.NUMBER, '0o666', 316, 38, 316, 43),
woosh.Token(woosh.OP, ')', 316, 43, 316, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 316, 44, 317, 0),
woosh.Token(woosh.DEDENT, ' ', 318, 0, 318, 4),
woosh.Token(woosh.NAME, 'def', 318, 4, 318, 7),
woosh.Token(woosh.NAME, 'close', 318, 8, 318, 13),
woosh.Token(woosh.OP, '(', 318, 13, 318, 14),
woosh.Token(woosh.NAME, 'self', 318, 14, 318, 18),
woosh.Token(woosh.OP, ')', 318, 18, 318, 19),
woosh.Token(woosh.OP, ':', 318, 19, 318, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 318, 20, 319, 0),
woosh.Token(woosh.INDENT, ' ', 319, 0, 319, 8),
woosh.Token(woosh.NAME, 'os', 319, 8, 319, 10),
woosh.Token(woosh.OP, '.', 319, 10, 319, 11),
woosh.Token(woosh.NAME, 'close', 319, 11, 319, 16),
woosh.Token(woosh.OP, '(', 319, 16, 319, 17),
woosh.Token(woosh.NAME, 'self', 319, 17, 319, 21),
woosh.Token(woosh.OP, '.', 319, 21, 319, 22),
woosh.Token(woosh.NAME, 'fd', 319, 22, 319, 24),
woosh.Token(woosh.OP, ')', 319, 24, 319, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 319, 25, 320, 0),
woosh.Token(woosh.DEDENT, ' ', 321, 0, 321, 4),
woosh.Token(woosh.NAME, 'def', 321, 4, 321, 7),
woosh.Token(woosh.NAME, 'read', 321, 8, 321, 12),
woosh.Token(woosh.OP, '(', 321, 12, 321, 13),
woosh.Token(woosh.NAME, 'self', 321, 13, 321, 17),
woosh.Token(woosh.OP, ',', 321, 17, 321, 18),
woosh.Token(woosh.NAME, 'size', 321, 19, 321, 23),
woosh.Token(woosh.OP, ')', 321, 23, 321, 24),
woosh.Token(woosh.OP, ':', 321, 24, 321, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 321, 25, 322, 0),
woosh.Token(woosh.INDENT, ' ', 322, 0, 322, 8),
woosh.Token(woosh.NAME, 'return', 322, 8, 322, 14),
woosh.Token(woosh.NAME, 'os', 322, 15, 322, 17),
woosh.Token(woosh.OP, '.', 322, 17, 322, 18),
woosh.Token(woosh.NAME, 'read', 322, 18, 322, 22),
woosh.Token(woosh.OP, '(', 322, 22, 322, 23),
woosh.Token(woosh.NAME, 'self', 322, 23, 322, 27),
woosh.Token(woosh.OP, '.', 322, 27, 322, 28),
woosh.Token(woosh.NAME, 'fd', 322, 28, 322, 30),
woosh.Token(woosh.OP, ',', 322, 30, 322, 31),
woosh.Token(woosh.NAME, 'size', 322, 32, 322, 36),
woosh.Token(woosh.OP, ')', 322, 36, 322, 37),
woosh.Token(woosh.NEWLINE, '\r\n', 322, 37, 323, 0),
woosh.Token(woosh.DEDENT, ' ', 324, 0, 324, 4),
woosh.Token(woosh.NAME, 'def', 324, 4, 324, 7),
woosh.Token(woosh.NAME, 'write', 324, 8, 324, 13),
woosh.Token(woosh.OP, '(', 324, 13, 324, 14),
woosh.Token(woosh.NAME, 'self', 324, 14, 324, 18),
woosh.Token(woosh.OP, ',', 324, 18, 324, 19),
woosh.Token(woosh.NAME, 's', 324, 20, 324, 21),
woosh.Token(woosh.OP, ')', 324, 21, 324, 22),
woosh.Token(woosh.OP, ':', 324, 22, 324, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 324, 23, 325, 0),
woosh.Token(woosh.INDENT, ' ', 325, 0, 325, 8),
woosh.Token(woosh.NAME, 'os', 325, 8, 325, 10),
woosh.Token(woosh.OP, '.', 325, 10, 325, 11),
woosh.Token(woosh.NAME, 'write', 325, 11, 325, 16),
woosh.Token(woosh.OP, '(', 325, 16, 325, 17),
woosh.Token(woosh.NAME, 'self', 325, 17, 325, 21),
woosh.Token(woosh.OP, '.', 325, 21, 325, 22),
woosh.Token(woosh.NAME, 'fd', 325, 22, 325, 24),
woosh.Token(woosh.OP, ',', 325, 24, 325, 25),
woosh.Token(woosh.NAME, 's', 325, 26, 325, 27),
woosh.Token(woosh.OP, ')', 325, 27, 325, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 325, 28, 326, 0),
woosh.Token(woosh.DEDENT, '', 327, 0, 327, 0),
woosh.Token(woosh.DEDENT, '', 327, 0, 327, 0),
woosh.Token(woosh.NAME, 'class', 327, 0, 327, 5),
woosh.Token(woosh.NAME, '_Stream', 327, 6, 327, 13),
woosh.Token(woosh.OP, ':', 327, 13, 327, 14),
woosh.Token(woosh.NEWLINE, '\r\n', 327, 14, 328, 0),
woosh.Token(woosh.INDENT, ' ', 328, 0, 328, 4),
woosh.Token(woosh.STRING, '"""Class that serves as an adapter between TarFile and\r\n a stream-like object. The stream-like object only\r\n needs to have a read() or write() method and is accessed\r\n blockwise. Use of gzip or bzip2 compression is possible.\r\n A stream-like object could be for example: sys.stdin,\r\n sys.stdout, a socket, a tape device etc.\r\n\r\n _Stream is intended to be used only internally.\r\n """', 328, 4, 336, 7),
woosh.Token(woosh.NEWLINE, '\r\n', 336, 7, 337, 0),
woosh.Token(woosh.NAME, 'def', 338, 4, 338, 7),
woosh.Token(woosh.NAME, '__init__', 338, 8, 338, 16),
woosh.Token(woosh.OP, '(', 338, 16, 338, 17),
woosh.Token(woosh.NAME, 'self', 338, 17, 338, 21),
woosh.Token(woosh.OP, ',', 338, 21, 338, 22),
woosh.Token(woosh.NAME, 'name', 338, 23, 338, 27),
woosh.Token(woosh.OP, ',', 338, 27, 338, 28),
woosh.Token(woosh.NAME, 'mode', 338, 29, 338, 33),
woosh.Token(woosh.OP, ',', 338, 33, 338, 34),
woosh.Token(woosh.NAME, 'comptype', 338, 35, 338, 43),
woosh.Token(woosh.OP, ',', 338, 43, 338, 44),
woosh.Token(woosh.NAME, 'fileobj', 338, 45, 338, 52),
woosh.Token(woosh.OP, ',', 338, 52, 338, 53),
woosh.Token(woosh.NAME, 'bufsize', 338, 54, 338, 61),
woosh.Token(woosh.OP, ')', 338, 61, 338, 62),
woosh.Token(woosh.OP, ':', 338, 62, 338, 63),
woosh.Token(woosh.NEWLINE, '\r\n', 338, 63, 339, 0),
woosh.Token(woosh.INDENT, ' ', 339, 0, 339, 8),
woosh.Token(woosh.STRING, '"""Construct a _Stream object.\r\n """', 339, 8, 340, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 340, 11, 341, 0),
woosh.Token(woosh.NAME, 'self', 341, 8, 341, 12),
woosh.Token(woosh.OP, '.', 341, 12, 341, 13),
woosh.Token(woosh.NAME, '_extfileobj', 341, 13, 341, 24),
woosh.Token(woosh.OP, '=', 341, 25, 341, 26),
woosh.Token(woosh.NAME, 'True', 341, 27, 341, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 341, 31, 342, 0),
woosh.Token(woosh.NAME, 'if', 342, 8, 342, 10),
woosh.Token(woosh.NAME, 'fileobj', 342, 11, 342, 18),
woosh.Token(woosh.NAME, 'is', 342, 19, 342, 21),
woosh.Token(woosh.NAME, 'None', 342, 22, 342, 26),
woosh.Token(woosh.OP, ':', 342, 26, 342, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 342, 27, 343, 0),
woosh.Token(woosh.INDENT, ' ', 343, 0, 343, 12),
woosh.Token(woosh.NAME, 'fileobj', 343, 12, 343, 19),
woosh.Token(woosh.OP, '=', 343, 20, 343, 21),
woosh.Token(woosh.NAME, '_LowLevelFile', 343, 22, 343, 35),
woosh.Token(woosh.OP, '(', 343, 35, 343, 36),
woosh.Token(woosh.NAME, 'name', 343, 36, 343, 40),
woosh.Token(woosh.OP, ',', 343, 40, 343, 41),
woosh.Token(woosh.NAME, 'mode', 343, 42, 343, 46),
woosh.Token(woosh.OP, ')', 343, 46, 343, 47),
woosh.Token(woosh.NEWLINE, '\r\n', 343, 47, 344, 0),
woosh.Token(woosh.NAME, 'self', 344, 12, 344, 16),
woosh.Token(woosh.OP, '.', 344, 16, 344, 17),
woosh.Token(woosh.NAME, '_extfileobj', 344, 17, 344, 28),
woosh.Token(woosh.OP, '=', 344, 29, 344, 30),
woosh.Token(woosh.NAME, 'False', 344, 31, 344, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 344, 36, 345, 0),
woosh.Token(woosh.DEDENT, ' ', 346, 0, 346, 8),
woosh.Token(woosh.NAME, 'if', 346, 8, 346, 10),
woosh.Token(woosh.NAME, 'comptype', 346, 11, 346, 19),
woosh.Token(woosh.OP, '==', 346, 20, 346, 22),
woosh.Token(woosh.STRING, "'*'", 346, 23, 346, 26),
woosh.Token(woosh.OP, ':', 346, 26, 346, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 346, 27, 347, 0),
woosh.Token(woosh.COMMENT, '# Enable transparent compression detection for the', 347, 12, 347, 62),
woosh.Token(woosh.COMMENT, '# stream interface', 348, 12, 348, 30),
woosh.Token(woosh.INDENT, ' ', 349, 0, 349, 12),
woosh.Token(woosh.NAME, 'fileobj', 349, 12, 349, 19),
woosh.Token(woosh.OP, '=', 349, 20, 349, 21),
woosh.Token(woosh.NAME, '_StreamProxy', 349, 22, 349, 34),
woosh.Token(woosh.OP, '(', 349, 34, 349, 35),
woosh.Token(woosh.NAME, 'fileobj', 349, 35, 349, 42),
woosh.Token(woosh.OP, ')', 349, 42, 349, 43),
woosh.Token(woosh.NEWLINE, '\r\n', 349, 43, 350, 0),
woosh.Token(woosh.NAME, 'comptype', 350, 12, 350, 20),
woosh.Token(woosh.OP, '=', 350, 21, 350, 22),
woosh.Token(woosh.NAME, 'fileobj', 350, 23, 350, 30),
woosh.Token(woosh.OP, '.', 350, 30, 350, 31),
woosh.Token(woosh.NAME, 'getcomptype', 350, 31, 350, 42),
woosh.Token(woosh.OP, '(', 350, 42, 350, 43),
woosh.Token(woosh.OP, ')', 350, 43, 350, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 350, 44, 351, 0),
woosh.Token(woosh.DEDENT, ' ', 352, 0, 352, 8),
woosh.Token(woosh.NAME, 'self', 352, 8, 352, 12),
woosh.Token(woosh.OP, '.', 352, 12, 352, 13),
woosh.Token(woosh.NAME, 'name', 352, 13, 352, 17),
woosh.Token(woosh.OP, '=', 352, 22, 352, 23),
woosh.Token(woosh.NAME, 'name', 352, 24, 352, 28),
woosh.Token(woosh.NAME, 'or', 352, 29, 352, 31),
woosh.Token(woosh.STRING, '""', 352, 32, 352, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 352, 34, 353, 0),
woosh.Token(woosh.NAME, 'self', 353, 8, 353, 12),
woosh.Token(woosh.OP, '.', 353, 12, 353, 13),
woosh.Token(woosh.NAME, 'mode', 353, 13, 353, 17),
woosh.Token(woosh.OP, '=', 353, 22, 353, 23),
woosh.Token(woosh.NAME, 'mode', 353, 24, 353, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 353, 28, 354, 0),
woosh.Token(woosh.NAME, 'self', 354, 8, 354, 12),
woosh.Token(woosh.OP, '.', 354, 12, 354, 13),
woosh.Token(woosh.NAME, 'comptype', 354, 13, 354, 21),
woosh.Token(woosh.OP, '=', 354, 22, 354, 23),
woosh.Token(woosh.NAME, 'comptype', 354, 24, 354, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 354, 32, 355, 0),
woosh.Token(woosh.NAME, 'self', 355, 8, 355, 12),
woosh.Token(woosh.OP, '.', 355, 12, 355, 13),
woosh.Token(woosh.NAME, 'fileobj', 355, 13, 355, 20),
woosh.Token(woosh.OP, '=', 355, 22, 355, 23),
woosh.Token(woosh.NAME, 'fileobj', 355, 24, 355, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 355, 31, 356, 0),
woosh.Token(woosh.NAME, 'self', 356, 8, 356, 12),
woosh.Token(woosh.OP, '.', 356, 12, 356, 13),
woosh.Token(woosh.NAME, 'bufsize', 356, 13, 356, 20),
woosh.Token(woosh.OP, '=', 356, 22, 356, 23),
woosh.Token(woosh.NAME, 'bufsize', 356, 24, 356, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 356, 31, 357, 0),
woosh.Token(woosh.NAME, 'self', 357, 8, 357, 12),
woosh.Token(woosh.OP, '.', 357, 12, 357, 13),
woosh.Token(woosh.NAME, 'buf', 357, 13, 357, 16),
woosh.Token(woosh.OP, '=', 357, 22, 357, 23),
woosh.Token(woosh.STRING, 'b""', 357, 24, 357, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 357, 27, 358, 0),
woosh.Token(woosh.NAME, 'self', 358, 8, 358, 12),
woosh.Token(woosh.OP, '.', 358, 12, 358, 13),
woosh.Token(woosh.NAME, 'pos', 358, 13, 358, 16),
woosh.Token(woosh.OP, '=', 358, 22, 358, 23),
woosh.Token(woosh.NUMBER, '0', 358, 24, 358, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 358, 25, 359, 0),
woosh.Token(woosh.NAME, 'self', 359, 8, 359, 12),
woosh.Token(woosh.OP, '.', 359, 12, 359, 13),
woosh.Token(woosh.NAME, 'closed', 359, 13, 359, 19),
woosh.Token(woosh.OP, '=', 359, 22, 359, 23),
woosh.Token(woosh.NAME, 'False', 359, 24, 359, 29),
woosh.Token(woosh.NEWLINE, '\r\n', 359, 29, 360, 0),
woosh.Token(woosh.NAME, 'try', 361, 8, 361, 11),
woosh.Token(woosh.OP, ':', 361, 11, 361, 12),
woosh.Token(woosh.NEWLINE, '\r\n', 361, 12, 362, 0),
woosh.Token(woosh.INDENT, ' ', 362, 0, 362, 12),
woosh.Token(woosh.NAME, 'if', 362, 12, 362, 14),
woosh.Token(woosh.NAME, 'comptype', 362, 15, 362, 23),
woosh.Token(woosh.OP, '==', 362, 24, 362, 26),
woosh.Token(woosh.STRING, '"gz"', 362, 27, 362, 31),
woosh.Token(woosh.OP, ':', 362, 31, 362, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 362, 32, 363, 0),
woosh.Token(woosh.INDENT, ' ', 363, 0, 363, 16),
woosh.Token(woosh.NAME, 'try', 363, 16, 363, 19),
woosh.Token(woosh.OP, ':', 363, 19, 363, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 363, 20, 364, 0),
woosh.Token(woosh.INDENT, ' ', 364, 0, 364, 20),
woosh.Token(woosh.NAME, 'import', 364, 20, 364, 26),
woosh.Token(woosh.NAME, 'zlib', 364, 27, 364, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 364, 31, 365, 0),
woosh.Token(woosh.DEDENT, ' ', 365, 0, 365, 16),
woosh.Token(woosh.NAME, 'except', 365, 16, 365, 22),
woosh.Token(woosh.NAME, 'ImportError', 365, 23, 365, 34),
woosh.Token(woosh.OP, ':', 365, 34, 365, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 365, 35, 366, 0),
woosh.Token(woosh.INDENT, ' ', 366, 0, 366, 20),
woosh.Token(woosh.NAME, 'raise', 366, 20, 366, 25),
woosh.Token(woosh.NAME, 'CompressionError', 366, 26, 366, 42),
woosh.Token(woosh.OP, '(', 366, 42, 366, 43),
woosh.Token(woosh.STRING, '"zlib module is not available"', 366, 43, 366, 73),
woosh.Token(woosh.OP, ')', 366, 73, 366, 74),
woosh.Token(woosh.NEWLINE, '\r\n', 366, 74, 367, 0),
woosh.Token(woosh.DEDENT, ' ', 367, 0, 367, 16),
woosh.Token(woosh.NAME, 'self', 367, 16, 367, 20),
woosh.Token(woosh.OP, '.', 367, 20, 367, 21),
woosh.Token(woosh.NAME, 'zlib', 367, 21, 367, 25),
woosh.Token(woosh.OP, '=', 367, 26, 367, 27),
woosh.Token(woosh.NAME, 'zlib', 367, 28, 367, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 367, 32, 368, 0),
woosh.Token(woosh.NAME, 'self', 368, 16, 368, 20),
woosh.Token(woosh.OP, '.', 368, 20, 368, 21),
woosh.Token(woosh.NAME, 'crc', 368, 21, 368, 24),
woosh.Token(woosh.OP, '=', 368, 25, 368, 26),
woosh.Token(woosh.NAME, 'zlib', 368, 27, 368, 31),
woosh.Token(woosh.OP, '.', 368, 31, 368, 32),
woosh.Token(woosh.NAME, 'crc32', 368, 32, 368, 37),
woosh.Token(woosh.OP, '(', 368, 37, 368, 38),
woosh.Token(woosh.STRING, 'b""', 368, 38, 368, 41),
woosh.Token(woosh.OP, ')', 368, 41, 368, 42),
woosh.Token(woosh.NEWLINE, '\r\n', 368, 42, 369, 0),
woosh.Token(woosh.NAME, 'if', 369, 16, 369, 18),
woosh.Token(woosh.NAME, 'mode', 369, 19, 369, 23),
woosh.Token(woosh.OP, '==', 369, 24, 369, 26),
woosh.Token(woosh.STRING, '"r"', 369, 27, 369, 30),
woosh.Token(woosh.OP, ':', 369, 30, 369, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 369, 31, 370, 0),
woosh.Token(woosh.INDENT, ' ', 370, 0, 370, 20),
woosh.Token(woosh.NAME, 'self', 370, 20, 370, 24),
woosh.Token(woosh.OP, '.', 370, 24, 370, 25),
woosh.Token(woosh.NAME, '_init_read_gz', 370, 25, 370, 38),
woosh.Token(woosh.OP, '(', 370, 38, 370, 39),
woosh.Token(woosh.OP, ')', 370, 39, 370, 40),
woosh.Token(woosh.NEWLINE, '\r\n', 370, 40, 371, 0),
woosh.Token(woosh.NAME, 'self', 371, 20, 371, 24),
woosh.Token(woosh.OP, '.', 371, 24, 371, 25),
woosh.Token(woosh.NAME, 'exception', 371, 25, 371, 34),
woosh.Token(woosh.OP, '=', 371, 35, 371, 36),
woosh.Token(woosh.NAME, 'zlib', 371, 37, 371, 41),
woosh.Token(woosh.OP, '.', 371, 41, 371, 42),
woosh.Token(woosh.NAME, 'error', 371, 42, 371, 47),
woosh.Token(woosh.NEWLINE, '\r\n', 371, 47, 372, 0),
woosh.Token(woosh.DEDENT, ' ', 372, 0, 372, 16),
woosh.Token(woosh.NAME, 'else', 372, 16, 372, 20),
woosh.Token(woosh.OP, ':', 372, 20, 372, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 372, 21, 373, 0),
woosh.Token(woosh.INDENT, ' ', 373, 0, 373, 20),
woosh.Token(woosh.NAME, 'self', 373, 20, 373, 24),
woosh.Token(woosh.OP, '.', 373, 24, 373, 25),
woosh.Token(woosh.NAME, '_init_write_gz', 373, 25, 373, 39),
woosh.Token(woosh.OP, '(', 373, 39, 373, 40),
woosh.Token(woosh.OP, ')', 373, 40, 373, 41),
woosh.Token(woosh.NEWLINE, '\r\n', 373, 41, 374, 0),
woosh.Token(woosh.DEDENT, ' ', 375, 0, 375, 12),
woosh.Token(woosh.DEDENT, '', 375, 12, 375, 12),
woosh.Token(woosh.NAME, 'elif', 375, 12, 375, 16),
woosh.Token(woosh.NAME, 'comptype', 375, 17, 375, 25),
woosh.Token(woosh.OP, '==', 375, 26, 375, 28),
woosh.Token(woosh.STRING, '"bz2"', 375, 29, 375, 34),
woosh.Token(woosh.OP, ':', 375, 34, 375, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 375, 35, 376, 0),
woosh.Token(woosh.INDENT, ' ', 376, 0, 376, 16),
woosh.Token(woosh.NAME, 'try', 376, 16, 376, 19),
woosh.Token(woosh.OP, ':', 376, 19, 376, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 376, 20, 377, 0),
woosh.Token(woosh.INDENT, ' ', 377, 0, 377, 20),
woosh.Token(woosh.NAME, 'import', 377, 20, 377, 26),
woosh.Token(woosh.NAME, 'bz2', 377, 27, 377, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 377, 30, 378, 0),
woosh.Token(woosh.DEDENT, ' ', 378, 0, 378, 16),
woosh.Token(woosh.NAME, 'except', 378, 16, 378, 22),
woosh.Token(woosh.NAME, 'ImportError', 378, 23, 378, 34),
woosh.Token(woosh.OP, ':', 378, 34, 378, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 378, 35, 379, 0),
woosh.Token(woosh.INDENT, ' ', 379, 0, 379, 20),
woosh.Token(woosh.NAME, 'raise', 379, 20, 379, 25),
woosh.Token(woosh.NAME, 'CompressionError', 379, 26, 379, 42),
woosh.Token(woosh.OP, '(', 379, 42, 379, 43),
woosh.Token(woosh.STRING, '"bz2 module is not available"', 379, 43, 379, 72),
woosh.Token(woosh.OP, ')', 379, 72, 379, 73),
woosh.Token(woosh.NEWLINE, '\r\n', 379, 73, 380, 0),
woosh.Token(woosh.DEDENT, ' ', 380, 0, 380, 16),
woosh.Token(woosh.NAME, 'if', 380, 16, 380, 18),
woosh.Token(woosh.NAME, 'mode', 380, 19, 380, 23),
woosh.Token(woosh.OP, '==', 380, 24, 380, 26),
woosh.Token(woosh.STRING, '"r"', 380, 27, 380, 30),
woosh.Token(woosh.OP, ':', 380, 30, 380, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 380, 31, 381, 0),
woosh.Token(woosh.INDENT, ' ', 381, 0, 381, 20),
woosh.Token(woosh.NAME, 'self', 381, 20, 381, 24),
woosh.Token(woosh.OP, '.', 381, 24, 381, 25),
woosh.Token(woosh.NAME, 'dbuf', 381, 25, 381, 29),
woosh.Token(woosh.OP, '=', 381, 30, 381, 31),
woosh.Token(woosh.STRING, 'b""', 381, 32, 381, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 381, 35, 382, 0),
woosh.Token(woosh.NAME, 'self', 382, 20, 382, 24),
woosh.Token(woosh.OP, '.', 382, 24, 382, 25),
woosh.Token(woosh.NAME, 'cmp', 382, 25, 382, 28),
woosh.Token(woosh.OP, '=', 382, 29, 382, 30),
woosh.Token(woosh.NAME, 'bz2', 382, 31, 382, 34),
woosh.Token(woosh.OP, '.', 382, 34, 382, 35),
woosh.Token(woosh.NAME, 'BZ2Decompressor', 382, 35, 382, 50),
woosh.Token(woosh.OP, '(', 382, 50, 382, 51),
woosh.Token(woosh.OP, ')', 382, 51, 382, 52),
woosh.Token(woosh.NEWLINE, '\r\n', 382, 52, 383, 0),
woosh.Token(woosh.NAME, 'self', 383, 20, 383, 24),
woosh.Token(woosh.OP, '.', 383, 24, 383, 25),
woosh.Token(woosh.NAME, 'exception', 383, 25, 383, 34),
woosh.Token(woosh.OP, '=', 383, 35, 383, 36),
woosh.Token(woosh.NAME, 'OSError', 383, 37, 383, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 383, 44, 384, 0),
woosh.Token(woosh.DEDENT, ' ', 384, 0, 384, 16),
woosh.Token(woosh.NAME, 'else', 384, 16, 384, 20),
woosh.Token(woosh.OP, ':', 384, 20, 384, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 384, 21, 385, 0),
woosh.Token(woosh.INDENT, ' ', 385, 0, 385, 20),
woosh.Token(woosh.NAME, 'self', 385, 20, 385, 24),
woosh.Token(woosh.OP, '.', 385, 24, 385, 25),
woosh.Token(woosh.NAME, 'cmp', 385, 25, 385, 28),
woosh.Token(woosh.OP, '=', 385, 29, 385, 30),
woosh.Token(woosh.NAME, 'bz2', 385, 31, 385, 34),
woosh.Token(woosh.OP, '.', 385, 34, 385, 35),
woosh.Token(woosh.NAME, 'BZ2Compressor', 385, 35, 385, 48),
woosh.Token(woosh.OP, '(', 385, 48, 385, 49),
woosh.Token(woosh.OP, ')', 385, 49, 385, 50),
woosh.Token(woosh.NEWLINE, '\r\n', 385, 50, 386, 0),
woosh.Token(woosh.DEDENT, ' ', 387, 0, 387, 12),
woosh.Token(woosh.DEDENT, '', 387, 12, 387, 12),
woosh.Token(woosh.NAME, 'elif', 387, 12, 387, 16),
woosh.Token(woosh.NAME, 'comptype', 387, 17, 387, 25),
woosh.Token(woosh.OP, '==', 387, 26, 387, 28),
woosh.Token(woosh.STRING, '"xz"', 387, 29, 387, 33),
woosh.Token(woosh.OP, ':', 387, 33, 387, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 387, 34, 388, 0),
woosh.Token(woosh.INDENT, ' ', 388, 0, 388, 16),
woosh.Token(woosh.NAME, 'try', 388, 16, 388, 19),
woosh.Token(woosh.OP, ':', 388, 19, 388, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 388, 20, 389, 0),
woosh.Token(woosh.INDENT, ' ', 389, 0, 389, 20),
woosh.Token(woosh.NAME, 'import', 389, 20, 389, 26),
woosh.Token(woosh.NAME, 'lzma', 389, 27, 389, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 389, 31, 390, 0),
woosh.Token(woosh.DEDENT, ' ', 390, 0, 390, 16),
woosh.Token(woosh.NAME, 'except', 390, 16, 390, 22),
woosh.Token(woosh.NAME, 'ImportError', 390, 23, 390, 34),
woosh.Token(woosh.OP, ':', 390, 34, 390, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 390, 35, 391, 0),
woosh.Token(woosh.INDENT, ' ', 391, 0, 391, 20),
woosh.Token(woosh.NAME, 'raise', 391, 20, 391, 25),
woosh.Token(woosh.NAME, 'CompressionError', 391, 26, 391, 42),
woosh.Token(woosh.OP, '(', 391, 42, 391, 43),
woosh.Token(woosh.STRING, '"lzma module is not available"', 391, 43, 391, 73),
woosh.Token(woosh.OP, ')', 391, 73, 391, 74),
woosh.Token(woosh.NEWLINE, '\r\n', 391, 74, 392, 0),
woosh.Token(woosh.DEDENT, ' ', 392, 0, 392, 16),
woosh.Token(woosh.NAME, 'if', 392, 16, 392, 18),
woosh.Token(woosh.NAME, 'mode', 392, 19, 392, 23),
woosh.Token(woosh.OP, '==', 392, 24, 392, 26),
woosh.Token(woosh.STRING, '"r"', 392, 27, 392, 30),
woosh.Token(woosh.OP, ':', 392, 30, 392, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 392, 31, 393, 0),
woosh.Token(woosh.INDENT, ' ', 393, 0, 393, 20),
woosh.Token(woosh.NAME, 'self', 393, 20, 393, 24),
woosh.Token(woosh.OP, '.', 393, 24, 393, 25),
woosh.Token(woosh.NAME, 'dbuf', 393, 25, 393, 29),
woosh.Token(woosh.OP, '=', 393, 30, 393, 31),
woosh.Token(woosh.STRING, 'b""', 393, 32, 393, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 393, 35, 394, 0),
woosh.Token(woosh.NAME, 'self', 394, 20, 394, 24),
woosh.Token(woosh.OP, '.', 394, 24, 394, 25),
woosh.Token(woosh.NAME, 'cmp', 394, 25, 394, 28),
woosh.Token(woosh.OP, '=', 394, 29, 394, 30),
woosh.Token(woosh.NAME, 'lzma', 394, 31, 394, 35),
woosh.Token(woosh.OP, '.', 394, 35, 394, 36),
woosh.Token(woosh.NAME, 'LZMADecompressor', 394, 36, 394, 52),
woosh.Token(woosh.OP, '(', 394, 52, 394, 53),
woosh.Token(woosh.OP, ')', 394, 53, 394, 54),
woosh.Token(woosh.NEWLINE, '\r\n', 394, 54, 395, 0),
woosh.Token(woosh.NAME, 'self', 395, 20, 395, 24),
woosh.Token(woosh.OP, '.', 395, 24, 395, 25),
woosh.Token(woosh.NAME, 'exception', 395, 25, 395, 34),
woosh.Token(woosh.OP, '=', 395, 35, 395, 36),
woosh.Token(woosh.NAME, 'lzma', 395, 37, 395, 41),
woosh.Token(woosh.OP, '.', 395, 41, 395, 42),
woosh.Token(woosh.NAME, 'LZMAError', 395, 42, 395, 51),
woosh.Token(woosh.NEWLINE, '\r\n', 395, 51, 396, 0),
woosh.Token(woosh.DEDENT, ' ', 396, 0, 396, 16),
woosh.Token(woosh.NAME, 'else', 396, 16, 396, 20),
woosh.Token(woosh.OP, ':', 396, 20, 396, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 396, 21, 397, 0),
woosh.Token(woosh.INDENT, ' ', 397, 0, 397, 20),
woosh.Token(woosh.NAME, 'self', 397, 20, 397, 24),
woosh.Token(woosh.OP, '.', 397, 24, 397, 25),
woosh.Token(woosh.NAME, 'cmp', 397, 25, 397, 28),
woosh.Token(woosh.OP, '=', 397, 29, 397, 30),
woosh.Token(woosh.NAME, 'lzma', 397, 31, 397, 35),
woosh.Token(woosh.OP, '.', 397, 35, 397, 36),
woosh.Token(woosh.NAME, 'LZMACompressor', 397, 36, 397, 50),
woosh.Token(woosh.OP, '(', 397, 50, 397, 51),
woosh.Token(woosh.OP, ')', 397, 51, 397, 52),
woosh.Token(woosh.NEWLINE, '\r\n', 397, 52, 398, 0),
woosh.Token(woosh.DEDENT, ' ', 399, 0, 399, 12),
woosh.Token(woosh.DEDENT, '', 399, 12, 399, 12),
woosh.Token(woosh.NAME, 'elif', 399, 12, 399, 16),
woosh.Token(woosh.NAME, 'comptype', 399, 17, 399, 25),
woosh.Token(woosh.OP, '!=', 399, 26, 399, 28),
woosh.Token(woosh.STRING, '"tar"', 399, 29, 399, 34),
woosh.Token(woosh.OP, ':', 399, 34, 399, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 399, 35, 400, 0),
woosh.Token(woosh.INDENT, ' ', 400, 0, 400, 16),
woosh.Token(woosh.NAME, 'raise', 400, 16, 400, 21),
woosh.Token(woosh.NAME, 'CompressionError', 400, 22, 400, 38),
woosh.Token(woosh.OP, '(', 400, 38, 400, 39),
woosh.Token(woosh.STRING, '"unknown compression type %r"', 400, 39, 400, 68),
woosh.Token(woosh.OP, '%', 400, 69, 400, 70),
woosh.Token(woosh.NAME, 'comptype', 400, 71, 400, 79),
woosh.Token(woosh.OP, ')', 400, 79, 400, 80),
woosh.Token(woosh.NEWLINE, '\r\n', 400, 80, 401, 0),
woosh.Token(woosh.DEDENT, ' ', 402, 0, 402, 8),
woosh.Token(woosh.DEDENT, '', 402, 8, 402, 8),
woosh.Token(woosh.NAME, 'except', 402, 8, 402, 14),
woosh.Token(woosh.OP, ':', 402, 14, 402, 15),
woosh.Token(woosh.NEWLINE, '\r\n', 402, 15, 403, 0),
woosh.Token(woosh.INDENT, ' ', 403, 0, 403, 12),
woosh.Token(woosh.NAME, 'if', 403, 12, 403, 14),
woosh.Token(woosh.NAME, 'not', 403, 15, 403, 18),
woosh.Token(woosh.NAME, 'self', 403, 19, 403, 23),
woosh.Token(woosh.OP, '.', 403, 23, 403, 24),
woosh.Token(woosh.NAME, '_extfileobj', 403, 24, 403, 35),
woosh.Token(woosh.OP, ':', 403, 35, 403, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 403, 36, 404, 0),
woosh.Token(woosh.INDENT, ' ', 404, 0, 404, 16),
woosh.Token(woosh.NAME, 'self', 404, 16, 404, 20),
woosh.Token(woosh.OP, '.', 404, 20, 404, 21),
woosh.Token(woosh.NAME, 'fileobj', 404, 21, 404, 28),
woosh.Token(woosh.OP, '.', 404, 28, 404, 29),
woosh.Token(woosh.NAME, 'close', 404, 29, 404, 34),
woosh.Token(woosh.OP, '(', 404, 34, 404, 35),
woosh.Token(woosh.OP, ')', 404, 35, 404, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 404, 36, 405, 0),
woosh.Token(woosh.DEDENT, ' ', 405, 0, 405, 12),
woosh.Token(woosh.NAME, 'self', 405, 12, 405, 16),
woosh.Token(woosh.OP, '.', 405, 16, 405, 17),
woosh.Token(woosh.NAME, 'closed', 405, 17, 405, 23),
woosh.Token(woosh.OP, '=', 405, 24, 405, 25),
woosh.Token(woosh.NAME, 'True', 405, 26, 405, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 405, 30, 406, 0),
woosh.Token(woosh.NAME, 'raise', 406, 12, 406, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 406, 17, 407, 0),
woosh.Token(woosh.DEDENT, ' ', 408, 0, 408, 4),
woosh.Token(woosh.DEDENT, '', 408, 4, 408, 4),
woosh.Token(woosh.NAME, 'def', 408, 4, 408, 7),
woosh.Token(woosh.NAME, '__del__', 408, 8, 408, 15),
woosh.Token(woosh.OP, '(', 408, 15, 408, 16),
woosh.Token(woosh.NAME, 'self', 408, 16, 408, 20),
woosh.Token(woosh.OP, ')', 408, 20, 408, 21),
woosh.Token(woosh.OP, ':', 408, 21, 408, 22),
woosh.Token(woosh.NEWLINE, '\r\n', 408, 22, 409, 0),
woosh.Token(woosh.INDENT, ' ', 409, 0, 409, 8),
woosh.Token(woosh.NAME, 'if', 409, 8, 409, 10),
woosh.Token(woosh.NAME, 'hasattr', 409, 11, 409, 18),
woosh.Token(woosh.OP, '(', 409, 18, 409, 19),
woosh.Token(woosh.NAME, 'self', 409, 19, 409, 23),
woosh.Token(woosh.OP, ',', 409, 23, 409, 24),
woosh.Token(woosh.STRING, '"closed"', 409, 25, 409, 33),
woosh.Token(woosh.OP, ')', 409, 33, 409, 34),
woosh.Token(woosh.NAME, 'and', 409, 35, 409, 38),
woosh.Token(woosh.NAME, 'not', 409, 39, 409, 42),
woosh.Token(woosh.NAME, 'self', 409, 43, 409, 47),
woosh.Token(woosh.OP, '.', 409, 47, 409, 48),
woosh.Token(woosh.NAME, 'closed', 409, 48, 409, 54),
woosh.Token(woosh.OP, ':', 409, 54, 409, 55),
woosh.Token(woosh.NEWLINE, '\r\n', 409, 55, 410, 0),
woosh.Token(woosh.INDENT, ' ', 410, 0, 410, 12),
woosh.Token(woosh.NAME, 'self', 410, 12, 410, 16),
woosh.Token(woosh.OP, '.', 410, 16, 410, 17),
woosh.Token(woosh.NAME, 'close', 410, 17, 410, 22),
woosh.Token(woosh.OP, '(', 410, 22, 410, 23),
woosh.Token(woosh.OP, ')', 410, 23, 410, 24),
woosh.Token(woosh.NEWLINE, '\r\n', 410, 24, 411, 0),
woosh.Token(woosh.DEDENT, ' ', 412, 0, 412, 4),
woosh.Token(woosh.DEDENT, '', 412, 4, 412, 4),
woosh.Token(woosh.NAME, 'def', 412, 4, 412, 7),
woosh.Token(woosh.NAME, '_init_write_gz', 412, 8, 412, 22),
woosh.Token(woosh.OP, '(', 412, 22, 412, 23),
woosh.Token(woosh.NAME, 'self', 412, 23, 412, 27),
woosh.Token(woosh.OP, ')', 412, 27, 412, 28),
woosh.Token(woosh.OP, ':', 412, 28, 412, 29),
woosh.Token(woosh.NEWLINE, '\r\n', 412, 29, 413, 0),
woosh.Token(woosh.INDENT, ' ', 413, 0, 413, 8),
woosh.Token(woosh.STRING, '"""Initialize for writing with gzip compression.\r\n """', 413, 8, 414, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 414, 11, 415, 0),
woosh.Token(woosh.NAME, 'self', 415, 8, 415, 12),
woosh.Token(woosh.OP, '.', 415, 12, 415, 13),
woosh.Token(woosh.NAME, 'cmp', 415, 13, 415, 16),
woosh.Token(woosh.OP, '=', 415, 17, 415, 18),
woosh.Token(woosh.NAME, 'self', 415, 19, 415, 23),
woosh.Token(woosh.OP, '.', 415, 23, 415, 24),
woosh.Token(woosh.NAME, 'zlib', 415, 24, 415, 28),
woosh.Token(woosh.OP, '.', 415, 28, 415, 29),
woosh.Token(woosh.NAME, 'compressobj', 415, 29, 415, 40),
woosh.Token(woosh.OP, '(', 415, 40, 415, 41),
woosh.Token(woosh.NUMBER, '9', 415, 41, 415, 42),
woosh.Token(woosh.OP, ',', 415, 42, 415, 43),
woosh.Token(woosh.NAME, 'self', 415, 44, 415, 48),
woosh.Token(woosh.OP, '.', 415, 48, 415, 49),
woosh.Token(woosh.NAME, 'zlib', 415, 49, 415, 53),
woosh.Token(woosh.OP, '.', 415, 53, 415, 54),
woosh.Token(woosh.NAME, 'DEFLATED', 415, 54, 415, 62),
woosh.Token(woosh.OP, ',', 415, 62, 415, 63),
woosh.Token(woosh.OP, '-', 416, 44, 416, 45),
woosh.Token(woosh.NAME, 'self', 416, 45, 416, 49),
woosh.Token(woosh.OP, '.', 416, 49, 416, 50),
woosh.Token(woosh.NAME, 'zlib', 416, 50, 416, 54),
woosh.Token(woosh.OP, '.', 416, 54, 416, 55),
woosh.Token(woosh.NAME, 'MAX_WBITS', 416, 55, 416, 64),
woosh.Token(woosh.OP, ',', 416, 64, 416, 65),
woosh.Token(woosh.NAME, 'self', 417, 44, 417, 48),
woosh.Token(woosh.OP, '.', 417, 48, 417, 49),
woosh.Token(woosh.NAME, 'zlib', 417, 49, 417, 53),
woosh.Token(woosh.OP, '.', 417, 53, 417, 54),
woosh.Token(woosh.NAME, 'DEF_MEM_LEVEL', 417, 54, 417, 67),
woosh.Token(woosh.OP, ',', 417, 67, 417, 68),
woosh.Token(woosh.NUMBER, '0', 418, 44, 418, 45),
woosh.Token(woosh.OP, ')', 418, 45, 418, 46),
woosh.Token(woosh.NEWLINE, '\r\n', 418, 46, 419, 0),
woosh.Token(woosh.NAME, 'timestamp', 419, 8, 419, 17),
woosh.Token(woosh.OP, '=', 419, 18, 419, 19),
woosh.Token(woosh.NAME, 'struct', 419, 20, 419, 26),
woosh.Token(woosh.OP, '.', 419, 26, 419, 27),
woosh.Token(woosh.NAME, 'pack', 419, 27, 419, 31),
woosh.Token(woosh.OP, '(', 419, 31, 419, 32),
woosh.Token(woosh.STRING, '"<L"', 419, 32, 419, 36),
woosh.Token(woosh.OP, ',', 419, 36, 419, 37),
woosh.Token(woosh.NAME, 'int', 419, 38, 419, 41),
woosh.Token(woosh.OP, '(', 419, 41, 419, 42),
woosh.Token(woosh.NAME, 'time', 419, 42, 419, 46),
woosh.Token(woosh.OP, '.', 419, 46, 419, 47),
woosh.Token(woosh.NAME, 'time', 419, 47, 419, 51),
woosh.Token(woosh.OP, '(', 419, 51, 419, 52),
woosh.Token(woosh.OP, ')', 419, 52, 419, 53),
woosh.Token(woosh.OP, ')', 419, 53, 419, 54),
woosh.Token(woosh.OP, ')', 419, 54, 419, 55),
woosh.Token(woosh.NEWLINE, '\r\n', 419, 55, 420, 0),
woosh.Token(woosh.NAME, 'self', 420, 8, 420, 12),
woosh.Token(woosh.OP, '.', 420, 12, 420, 13),
woosh.Token(woosh.NAME, '__write', 420, 13, 420, 20),
woosh.Token(woosh.OP, '(', 420, 20, 420, 21),
woosh.Token(woosh.STRING, 'b"\\037\\213\\010\\010"', 420, 21, 420, 40),
woosh.Token(woosh.OP, '+', 420, 41, 420, 42),
woosh.Token(woosh.NAME, 'timestamp', 420, 43, 420, 52),
woosh.Token(woosh.OP, '+', 420, 53, 420, 54),
woosh.Token(woosh.STRING, 'b"\\002\\377"', 420, 55, 420, 66),
woosh.Token(woosh.OP, ')', 420, 66, 420, 67),
woosh.Token(woosh.NEWLINE, '\r\n', 420, 67, 421, 0),
woosh.Token(woosh.NAME, 'if', 421, 8, 421, 10),
woosh.Token(woosh.NAME, 'self', 421, 11, 421, 15),
woosh.Token(woosh.OP, '.', 421, 15, 421, 16),
woosh.Token(woosh.NAME, 'name', 421, 16, 421, 20),
woosh.Token(woosh.OP, '.', 421, 20, 421, 21),
woosh.Token(woosh.NAME, 'endswith', 421, 21, 421, 29),
woosh.Token(woosh.OP, '(', 421, 29, 421, 30),
woosh.Token(woosh.STRING, '".gz"', 421, 30, 421, 35),
woosh.Token(woosh.OP, ')', 421, 35, 421, 36),
woosh.Token(woosh.OP, ':', 421, 36, 421, 37),
woosh.Token(woosh.NEWLINE, '\r\n', 421, 37, 422, 0),
woosh.Token(woosh.INDENT, ' ', 422, 0, 422, 12),
woosh.Token(woosh.NAME, 'self', 422, 12, 422, 16),
woosh.Token(woosh.OP, '.', 422, 16, 422, 17),
woosh.Token(woosh.NAME, 'name', 422, 17, 422, 21),
woosh.Token(woosh.OP, '=', 422, 22, 422, 23),
woosh.Token(woosh.NAME, 'self', 422, 24, 422, 28),
woosh.Token(woosh.OP, '.', 422, 28, 422, 29),
woosh.Token(woosh.NAME, 'name', 422, 29, 422, 33),
woosh.Token(woosh.OP, '[', 422, 33, 422, 34),
woosh.Token(woosh.OP, ':', 422, 34, 422, 35),
woosh.Token(woosh.OP, '-', 422, 35, 422, 36),
woosh.Token(woosh.NUMBER, '3', 422, 36, 422, 37),
woosh.Token(woosh.OP, ']', 422, 37, 422, 38),
woosh.Token(woosh.NEWLINE, '\r\n', 422, 38, 423, 0),
woosh.Token(woosh.COMMENT, '# Honor "directory components removed" from RFC1952', 423, 8, 423, 59),
woosh.Token(woosh.DEDENT, ' ', 424, 0, 424, 8),
woosh.Token(woosh.NAME, 'self', 424, 8, 424, 12),
woosh.Token(woosh.OP, '.', 424, 12, 424, 13),
woosh.Token(woosh.NAME, 'name', 424, 13, 424, 17),
woosh.Token(woosh.OP, '=', 424, 18, 424, 19),
woosh.Token(woosh.NAME, 'os', 424, 20, 424, 22),
woosh.Token(woosh.OP, '.', 424, 22, 424, 23),
woosh.Token(woosh.NAME, 'path', 424, 23, 424, 27),
woosh.Token(woosh.OP, '.', 424, 27, 424, 28),
woosh.Token(woosh.NAME, 'basename', 424, 28, 424, 36),
woosh.Token(woosh.OP, '(', 424, 36, 424, 37),
woosh.Token(woosh.NAME, 'self', 424, 37, 424, 41),
woosh.Token(woosh.OP, '.', 424, 41, 424, 42),
woosh.Token(woosh.NAME, 'name', 424, 42, 424, 46),
woosh.Token(woosh.OP, ')', 424, 46, 424, 47),
woosh.Token(woosh.NEWLINE, '\r\n', 424, 47, 425, 0),
woosh.Token(woosh.COMMENT, '# RFC1952 says we must use ISO-8859-1 for the FNAME field.', 425, 8, 425, 66),
woosh.Token(woosh.NAME, 'self', 426, 8, 426, 12),
woosh.Token(woosh.OP, '.', 426, 12, 426, 13),
woosh.Token(woosh.NAME, '__write', 426, 13, 426, 20),
woosh.Token(woosh.OP, '(', 426, 20, 426, 21),
woosh.Token(woosh.NAME, 'self', 426, 21, 426, 25),
woosh.Token(woosh.OP, '.', 426, 25, 426, 26),
woosh.Token(woosh.NAME, 'name', 426, 26, 426, 30),
woosh.Token(woosh.OP, '.', 426, 30, 426, 31),
woosh.Token(woosh.NAME, 'encode', 426, 31, 426, 37),
woosh.Token(woosh.OP, '(', 426, 37, 426, 38),
woosh.Token(woosh.STRING, '"iso-8859-1"', 426, 38, 426, 50),
woosh.Token(woosh.OP, ',', 426, 50, 426, 51),
woosh.Token(woosh.STRING, '"replace"', 426, 52, 426, 61),
woosh.Token(woosh.OP, ')', 426, 61, 426, 62),
woosh.Token(woosh.OP, '+', 426, 63, 426, 64),
woosh.Token(woosh.NAME, 'NUL', 426, 65, 426, 68),
woosh.Token(woosh.OP, ')', 426, 68, 426, 69),
woosh.Token(woosh.NEWLINE, '\r\n', 426, 69, 427, 0),
woosh.Token(woosh.DEDENT, ' ', 428, 0, 428, 4),
woosh.Token(woosh.NAME, 'def', 428, 4, 428, 7),
woosh.Token(woosh.NAME, 'write', 428, 8, 428, 13),
woosh.Token(woosh.OP, '(', 428, 13, 428, 14),
woosh.Token(woosh.NAME, 'self', 428, 14, 428, 18),
woosh.Token(woosh.OP, ',', 428, 18, 428, 19),
woosh.Token(woosh.NAME, 's', 428, 20, 428, 21),
woosh.Token(woosh.OP, ')', 428, 21, 428, 22),
woosh.Token(woosh.OP, ':', 428, 22, 428, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 428, 23, 429, 0),
woosh.Token(woosh.INDENT, ' ', 429, 0, 429, 8),
woosh.Token(woosh.STRING, '"""Write string s to the stream.\r\n """', 429, 8, 430, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 430, 11, 431, 0),
woosh.Token(woosh.NAME, 'if', 431, 8, 431, 10),
woosh.Token(woosh.NAME, 'self', 431, 11, 431, 15),
woosh.Token(woosh.OP, '.', 431, 15, 431, 16),
woosh.Token(woosh.NAME, 'comptype', 431, 16, 431, 24),
woosh.Token(woosh.OP, '==', 431, 25, 431, 27),
woosh.Token(woosh.STRING, '"gz"', 431, 28, 431, 32),
woosh.Token(woosh.OP, ':', 431, 32, 431, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 431, 33, 432, 0),
woosh.Token(woosh.INDENT, ' ', 432, 0, 432, 12),
woosh.Token(woosh.NAME, 'self', 432, 12, 432, 16),
woosh.Token(woosh.OP, '.', 432, 16, 432, 17),
woosh.Token(woosh.NAME, 'crc', 432, 17, 432, 20),
woosh.Token(woosh.OP, '=', 432, 21, 432, 22),
woosh.Token(woosh.NAME, 'self', 432, 23, 432, 27),
woosh.Token(woosh.OP, '.', 432, 27, 432, 28),
woosh.Token(woosh.NAME, 'zlib', 432, 28, 432, 32),
woosh.Token(woosh.OP, '.', 432, 32, 432, 33),
woosh.Token(woosh.NAME, 'crc32', 432, 33, 432, 38),
woosh.Token(woosh.OP, '(', 432, 38, 432, 39),
woosh.Token(woosh.NAME, 's', 432, 39, 432, 40),
woosh.Token(woosh.OP, ',', 432, 40, 432, 41),
woosh.Token(woosh.NAME, 'self', 432, 42, 432, 46),
woosh.Token(woosh.OP, '.', 432, 46, 432, 47),
woosh.Token(woosh.NAME, 'crc', 432, 47, 432, 50),
woosh.Token(woosh.OP, ')', 432, 50, 432, 51),
woosh.Token(woosh.NEWLINE, '\r\n', 432, 51, 433, 0),
woosh.Token(woosh.DEDENT, ' ', 433, 0, 433, 8),
woosh.Token(woosh.NAME, 'self', 433, 8, 433, 12),
woosh.Token(woosh.OP, '.', 433, 12, 433, 13),
woosh.Token(woosh.NAME, 'pos', 433, 13, 433, 16),
woosh.Token(woosh.OP, '+=', 433, 17, 433, 19),
woosh.Token(woosh.NAME, 'len', 433, 20, 433, 23),
woosh.Token(woosh.OP, '(', 433, 23, 433, 24),
woosh.Token(woosh.NAME, 's', 433, 24, 433, 25),
woosh.Token(woosh.OP, ')', 433, 25, 433, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 433, 26, 434, 0),
woosh.Token(woosh.NAME, 'if', 434, 8, 434, 10),
woosh.Token(woosh.NAME, 'self', 434, 11, 434, 15),
woosh.Token(woosh.OP, '.', 434, 15, 434, 16),
woosh.Token(woosh.NAME, 'comptype', 434, 16, 434, 24),
woosh.Token(woosh.OP, '!=', 434, 25, 434, 27),
woosh.Token(woosh.STRING, '"tar"', 434, 28, 434, 33),
woosh.Token(woosh.OP, ':', 434, 33, 434, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 434, 34, 435, 0),
woosh.Token(woosh.INDENT, ' ', 435, 0, 435, 12),
woosh.Token(woosh.NAME, 's', 435, 12, 435, 13),
woosh.Token(woosh.OP, '=', 435, 14, 435, 15),
woosh.Token(woosh.NAME, 'self', 435, 16, 435, 20),
woosh.Token(woosh.OP, '.', 435, 20, 435, 21),
woosh.Token(woosh.NAME, 'cmp', 435, 21, 435, 24),
woosh.Token(woosh.OP, '.', 435, 24, 435, 25),
woosh.Token(woosh.NAME, 'compress', 435, 25, 435, 33),
woosh.Token(woosh.OP, '(', 435, 33, 435, 34),
woosh.Token(woosh.NAME, 's', 435, 34, 435, 35),
woosh.Token(woosh.OP, ')', 435, 35, 435, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 435, 36, 436, 0),
woosh.Token(woosh.DEDENT, ' ', 436, 0, 436, 8),
woosh.Token(woosh.NAME, 'self', 436, 8, 436, 12),
woosh.Token(woosh.OP, '.', 436, 12, 436, 13),
woosh.Token(woosh.NAME, '__write', 436, 13, 436, 20),
woosh.Token(woosh.OP, '(', 436, 20, 436, 21),
woosh.Token(woosh.NAME, 's', 436, 21, 436, 22),
woosh.Token(woosh.OP, ')', 436, 22, 436, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 436, 23, 437, 0),
woosh.Token(woosh.DEDENT, ' ', 438, 0, 438, 4),
woosh.Token(woosh.NAME, 'def', 438, 4, 438, 7),
woosh.Token(woosh.NAME, '__write', 438, 8, 438, 15),
woosh.Token(woosh.OP, '(', 438, 15, 438, 16),
woosh.Token(woosh.NAME, 'self', 438, 16, 438, 20),
woosh.Token(woosh.OP, ',', 438, 20, 438, 21),
woosh.Token(woosh.NAME, 's', 438, 22, 438, 23),
woosh.Token(woosh.OP, ')', 438, 23, 438, 24),
woosh.Token(woosh.OP, ':', 438, 24, 438, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 438, 25, 439, 0),
woosh.Token(woosh.INDENT, ' ', 439, 0, 439, 8),
woosh.Token(woosh.STRING, '"""Write string s to the stream if a whole new block\r\n is ready to be written.\r\n """', 439, 8, 441, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 441, 11, 442, 0),
woosh.Token(woosh.NAME, 'self', 442, 8, 442, 12),
woosh.Token(woosh.OP, '.', 442, 12, 442, 13),
woosh.Token(woosh.NAME, 'buf', 442, 13, 442, 16),
woosh.Token(woosh.OP, '+=', 442, 17, 442, 19),
woosh.Token(woosh.NAME, 's', 442, 20, 442, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 442, 21, 443, 0),
woosh.Token(woosh.NAME, 'while', 443, 8, 443, 13),
woosh.Token(woosh.NAME, 'len', 443, 14, 443, 17),
woosh.Token(woosh.OP, '(', 443, 17, 443, 18),
woosh.Token(woosh.NAME, 'self', 443, 18, 443, 22),
woosh.Token(woosh.OP, '.', 443, 22, 443, 23),
woosh.Token(woosh.NAME, 'buf', 443, 23, 443, 26),
woosh.Token(woosh.OP, ')', 443, 26, 443, 27),
woosh.Token(woosh.OP, '>', 443, 28, 443, 29),
woosh.Token(woosh.NAME, 'self', 443, 30, 443, 34),
woosh.Token(woosh.OP, '.', 443, 34, 443, 35),
woosh.Token(woosh.NAME, 'bufsize', 443, 35, 443, 42),
woosh.Token(woosh.OP, ':', 443, 42, 443, 43),
woosh.Token(woosh.NEWLINE, '\r\n', 443, 43, 444, 0),
woosh.Token(woosh.INDENT, ' ', 444, 0, 444, 12),
woosh.Token(woosh.NAME, 'self', 444, 12, 444, 16),
woosh.Token(woosh.OP, '.', 444, 16, 444, 17),
woosh.Token(woosh.NAME, 'fileobj', 444, 17, 444, 24),
woosh.Token(woosh.OP, '.', 444, 24, 444, 25),
woosh.Token(woosh.NAME, 'write', 444, 25, 444, 30),
woosh.Token(woosh.OP, '(', 444, 30, 444, 31),
woosh.Token(woosh.NAME, 'self', 444, 31, 444, 35),
woosh.Token(woosh.OP, '.', 444, 35, 444, 36),
woosh.Token(woosh.NAME, 'buf', 444, 36, 444, 39),
woosh.Token(woosh.OP, '[', 444, 39, 444, 40),
woosh.Token(woosh.OP, ':', 444, 40, 444, 41),
woosh.Token(woosh.NAME, 'self', 444, 41, 444, 45),
woosh.Token(woosh.OP, '.', 444, 45, 444, 46),
woosh.Token(woosh.NAME, 'bufsize', 444, 46, 444, 53),
woosh.Token(woosh.OP, ']', 444, 53, 444, 54),
woosh.Token(woosh.OP, ')', 444, 54, 444, 55),
woosh.Token(woosh.NEWLINE, '\r\n', 444, 55, 445, 0),
woosh.Token(woosh.NAME, 'self', 445, 12, 445, 16),
woosh.Token(woosh.OP, '.', 445, 16, 445, 17),
woosh.Token(woosh.NAME, 'buf', 445, 17, 445, 20),
woosh.Token(woosh.OP, '=', 445, 21, 445, 22),
woosh.Token(woosh.NAME, 'self', 445, 23, 445, 27),
woosh.Token(woosh.OP, '.', 445, 27, 445, 28),
woosh.Token(woosh.NAME, 'buf', 445, 28, 445, 31),
woosh.Token(woosh.OP, '[', 445, 31, 445, 32),
woosh.Token(woosh.NAME, 'self', 445, 32, 445, 36),
woosh.Token(woosh.OP, '.', 445, 36, 445, 37),
woosh.Token(woosh.NAME, 'bufsize', 445, 37, 445, 44),
woosh.Token(woosh.OP, ':', 445, 44, 445, 45),
woosh.Token(woosh.OP, ']', 445, 45, 445, 46),
woosh.Token(woosh.NEWLINE, '\r\n', 445, 46, 446, 0),
woosh.Token(woosh.DEDENT, ' ', 447, 0, 447, 4),
woosh.Token(woosh.DEDENT, '', 447, 4, 447, 4),
woosh.Token(woosh.NAME, 'def', 447, 4, 447, 7),
woosh.Token(woosh.NAME, 'close', 447, 8, 447, 13),
woosh.Token(woosh.OP, '(', 447, 13, 447, 14),
woosh.Token(woosh.NAME, 'self', 447, 14, 447, 18),
woosh.Token(woosh.OP, ')', 447, 18, 447, 19),
woosh.Token(woosh.OP, ':', 447, 19, 447, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 447, 20, 448, 0),
woosh.Token(woosh.INDENT, ' ', 448, 0, 448, 8),
woosh.Token(woosh.STRING, '"""Close the _Stream object. No operation should be\r\n done on it afterwards.\r\n """', 448, 8, 450, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 450, 11, 451, 0),
woosh.Token(woosh.NAME, 'if', 451, 8, 451, 10),
woosh.Token(woosh.NAME, 'self', 451, 11, 451, 15),
woosh.Token(woosh.OP, '.', 451, 15, 451, 16),
woosh.Token(woosh.NAME, 'closed', 451, 16, 451, 22),
woosh.Token(woosh.OP, ':', 451, 22, 451, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 451, 23, 452, 0),
woosh.Token(woosh.INDENT, ' ', 452, 0, 452, 12),
woosh.Token(woosh.NAME, 'return', 452, 12, 452, 18),
woosh.Token(woosh.NEWLINE, '\r\n', 452, 18, 453, 0),
woosh.Token(woosh.DEDENT, ' ', 454, 0, 454, 8),
woosh.Token(woosh.NAME, 'self', 454, 8, 454, 12),
woosh.Token(woosh.OP, '.', 454, 12, 454, 13),
woosh.Token(woosh.NAME, 'closed', 454, 13, 454, 19),
woosh.Token(woosh.OP, '=', 454, 20, 454, 21),
woosh.Token(woosh.NAME, 'True', 454, 22, 454, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 454, 26, 455, 0),
woosh.Token(woosh.NAME, 'try', 455, 8, 455, 11),
woosh.Token(woosh.OP, ':', 455, 11, 455, 12),
woosh.Token(woosh.NEWLINE, '\r\n', 455, 12, 456, 0),
woosh.Token(woosh.INDENT, ' ', 456, 0, 456, 12),
woosh.Token(woosh.NAME, 'if', 456, 12, 456, 14),
woosh.Token(woosh.NAME, 'self', 456, 15, 456, 19),
woosh.Token(woosh.OP, '.', 456, 19, 456, 20),
woosh.Token(woosh.NAME, 'mode', 456, 20, 456, 24),
woosh.Token(woosh.OP, '==', 456, 25, 456, 27),
woosh.Token(woosh.STRING, '"w"', 456, 28, 456, 31),
woosh.Token(woosh.NAME, 'and', 456, 32, 456, 35),
woosh.Token(woosh.NAME, 'self', 456, 36, 456, 40),
woosh.Token(woosh.OP, '.', 456, 40, 456, 41),
woosh.Token(woosh.NAME, 'comptype', 456, 41, 456, 49),
woosh.Token(woosh.OP, '!=', 456, 50, 456, 52),
woosh.Token(woosh.STRING, '"tar"', 456, 53, 456, 58),
woosh.Token(woosh.OP, ':', 456, 58, 456, 59),
woosh.Token(woosh.NEWLINE, '\r\n', 456, 59, 457, 0),
woosh.Token(woosh.INDENT, ' ', 457, 0, 457, 16),
woosh.Token(woosh.NAME, 'self', 457, 16, 457, 20),
woosh.Token(woosh.OP, '.', 457, 20, 457, 21),
woosh.Token(woosh.NAME, 'buf', 457, 21, 457, 24),
woosh.Token(woosh.OP, '+=', 457, 25, 457, 27),
woosh.Token(woosh.NAME, 'self', 457, 28, 457, 32),
woosh.Token(woosh.OP, '.', 457, 32, 457, 33),
woosh.Token(woosh.NAME, 'cmp', 457, 33, 457, 36),
woosh.Token(woosh.OP, '.', 457, 36, 457, 37),
woosh.Token(woosh.NAME, 'flush', 457, 37, 457, 42),
woosh.Token(woosh.OP, '(', 457, 42, 457, 43),
woosh.Token(woosh.OP, ')', 457, 43, 457, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 457, 44, 458, 0),
woosh.Token(woosh.DEDENT, ' ', 459, 0, 459, 12),
woosh.Token(woosh.NAME, 'if', 459, 12, 459, 14),
woosh.Token(woosh.NAME, 'self', 459, 15, 459, 19),
woosh.Token(woosh.OP, '.', 459, 19, 459, 20),
woosh.Token(woosh.NAME, 'mode', 459, 20, 459, 24),
woosh.Token(woosh.OP, '==', 459, 25, 459, 27),
woosh.Token(woosh.STRING, '"w"', 459, 28, 459, 31),
woosh.Token(woosh.NAME, 'and', 459, 32, 459, 35),
woosh.Token(woosh.NAME, 'self', 459, 36, 459, 40),
woosh.Token(woosh.OP, '.', 459, 40, 459, 41),
woosh.Token(woosh.NAME, 'buf', 459, 41, 459, 44),
woosh.Token(woosh.OP, ':', 459, 44, 459, 45),
woosh.Token(woosh.NEWLINE, '\r\n', 459, 45, 460, 0),
woosh.Token(woosh.INDENT, ' ', 460, 0, 460, 16),
woosh.Token(woosh.NAME, 'self', 460, 16, 460, 20),
woosh.Token(woosh.OP, '.', 460, 20, 460, 21),
woosh.Token(woosh.NAME, 'fileobj', 460, 21, 460, 28),
woosh.Token(woosh.OP, '.', 460, 28, 460, 29),
woosh.Token(woosh.NAME, 'write', 460, 29, 460, 34),
woosh.Token(woosh.OP, '(', 460, 34, 460, 35),
woosh.Token(woosh.NAME, 'self', 460, 35, 460, 39),
woosh.Token(woosh.OP, '.', 460, 39, 460, 40),
woosh.Token(woosh.NAME, 'buf', 460, 40, 460, 43),
woosh.Token(woosh.OP, ')', 460, 43, 460, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 460, 44, 461, 0),
woosh.Token(woosh.NAME, 'self', 461, 16, 461, 20),
woosh.Token(woosh.OP, '.', 461, 20, 461, 21),
woosh.Token(woosh.NAME, 'buf', 461, 21, 461, 24),
woosh.Token(woosh.OP, '=', 461, 25, 461, 26),
woosh.Token(woosh.STRING, 'b""', 461, 27, 461, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 461, 30, 462, 0),
woosh.Token(woosh.NAME, 'if', 462, 16, 462, 18),
woosh.Token(woosh.NAME, 'self', 462, 19, 462, 23),
woosh.Token(woosh.OP, '.', 462, 23, 462, 24),
woosh.Token(woosh.NAME, 'comptype', 462, 24, 462, 32),
woosh.Token(woosh.OP, '==', 462, 33, 462, 35),
woosh.Token(woosh.STRING, '"gz"', 462, 36, 462, 40),
woosh.Token(woosh.OP, ':', 462, 40, 462, 41),
woosh.Token(woosh.NEWLINE, '\r\n', 462, 41, 463, 0),
woosh.Token(woosh.INDENT, ' ', 463, 0, 463, 20),
woosh.Token(woosh.NAME, 'self', 463, 20, 463, 24),
woosh.Token(woosh.OP, '.', 463, 24, 463, 25),
woosh.Token(woosh.NAME, 'fileobj', 463, 25, 463, 32),
woosh.Token(woosh.OP, '.', 463, 32, 463, 33),
woosh.Token(woosh.NAME, 'write', 463, 33, 463, 38),
woosh.Token(woosh.OP, '(', 463, 38, 463, 39),
woosh.Token(woosh.NAME, 'struct', 463, 39, 463, 45),
woosh.Token(woosh.OP, '.', 463, 45, 463, 46),
woosh.Token(woosh.NAME, 'pack', 463, 46, 463, 50),
woosh.Token(woosh.OP, '(', 463, 50, 463, 51),
woosh.Token(woosh.STRING, '"<L"', 463, 51, 463, 55),
woosh.Token(woosh.OP, ',', 463, 55, 463, 56),
woosh.Token(woosh.NAME, 'self', 463, 57, 463, 61),
woosh.Token(woosh.OP, '.', 463, 61, 463, 62),
woosh.Token(woosh.NAME, 'crc', 463, 62, 463, 65),
woosh.Token(woosh.OP, ')', 463, 65, 463, 66),
woosh.Token(woosh.OP, ')', 463, 66, 463, 67),
woosh.Token(woosh.NEWLINE, '\r\n', 463, 67, 464, 0),
woosh.Token(woosh.NAME, 'self', 464, 20, 464, 24),
woosh.Token(woosh.OP, '.', 464, 24, 464, 25),
woosh.Token(woosh.NAME, 'fileobj', 464, 25, 464, 32),
woosh.Token(woosh.OP, '.', 464, 32, 464, 33),
woosh.Token(woosh.NAME, 'write', 464, 33, 464, 38),
woosh.Token(woosh.OP, '(', 464, 38, 464, 39),
woosh.Token(woosh.NAME, 'struct', 464, 39, 464, 45),
woosh.Token(woosh.OP, '.', 464, 45, 464, 46),
woosh.Token(woosh.NAME, 'pack', 464, 46, 464, 50),
woosh.Token(woosh.OP, '(', 464, 50, 464, 51),
woosh.Token(woosh.STRING, '"<L"', 464, 51, 464, 55),
woosh.Token(woosh.OP, ',', 464, 55, 464, 56),
woosh.Token(woosh.NAME, 'self', 464, 57, 464, 61),
woosh.Token(woosh.OP, '.', 464, 61, 464, 62),
woosh.Token(woosh.NAME, 'pos', 464, 62, 464, 65),
woosh.Token(woosh.OP, '&', 464, 66, 464, 67),
woosh.Token(woosh.NUMBER, '0xffffFFFF', 464, 68, 464, 78),
woosh.Token(woosh.OP, ')', 464, 78, 464, 79),
woosh.Token(woosh.OP, ')', 464, 79, 464, 80),
woosh.Token(woosh.NEWLINE, '\r\n', 464, 80, 465, 0),
woosh.Token(woosh.DEDENT, ' ', 465, 0, 465, 8),
woosh.Token(woosh.DEDENT, '', 465, 8, 465, 8),
woosh.Token(woosh.DEDENT, '', 465, 8, 465, 8),
woosh.Token(woosh.NAME, 'finally', 465, 8, 465, 15),
woosh.Token(woosh.OP, ':', 465, 15, 465, 16),
woosh.Token(woosh.NEWLINE, '\r\n', 465, 16, 466, 0),
woosh.Token(woosh.INDENT, ' ', 466, 0, 466, 12),
woosh.Token(woosh.NAME, 'if', 466, 12, 466, 14),
woosh.Token(woosh.NAME, 'not', 466, 15, 466, 18),
woosh.Token(woosh.NAME, 'self', 466, 19, 466, 23),
woosh.Token(woosh.OP, '.', 466, 23, 466, 24),
woosh.Token(woosh.NAME, '_extfileobj', 466, 24, 466, 35),
woosh.Token(woosh.OP, ':', 466, 35, 466, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 466, 36, 467, 0),
woosh.Token(woosh.INDENT, ' ', 467, 0, 467, 16),
woosh.Token(woosh.NAME, 'self', 467, 16, 467, 20),
woosh.Token(woosh.OP, '.', 467, 20, 467, 21),
woosh.Token(woosh.NAME, 'fileobj', 467, 21, 467, 28),
woosh.Token(woosh.OP, '.', 467, 28, 467, 29),
woosh.Token(woosh.NAME, 'close', 467, 29, 467, 34),
woosh.Token(woosh.OP, '(', 467, 34, 467, 35),
woosh.Token(woosh.OP, ')', 467, 35, 467, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 467, 36, 468, 0),
woosh.Token(woosh.DEDENT, ' ', 469, 0, 469, 4),
woosh.Token(woosh.DEDENT, '', 469, 4, 469, 4),
woosh.Token(woosh.DEDENT, '', 469, 4, 469, 4),
woosh.Token(woosh.NAME, 'def', 469, 4, 469, 7),
woosh.Token(woosh.NAME, '_init_read_gz', 469, 8, 469, 21),
woosh.Token(woosh.OP, '(', 469, 21, 469, 22),
woosh.Token(woosh.NAME, 'self', 469, 22, 469, 26),
woosh.Token(woosh.OP, ')', 469, 26, 469, 27),
woosh.Token(woosh.OP, ':', 469, 27, 469, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 469, 28, 470, 0),
woosh.Token(woosh.INDENT, ' ', 470, 0, 470, 8),
woosh.Token(woosh.STRING, '"""Initialize for reading a gzip compressed fileobj.\r\n """', 470, 8, 471, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 471, 11, 472, 0),
woosh.Token(woosh.NAME, 'self', 472, 8, 472, 12),
woosh.Token(woosh.OP, '.', 472, 12, 472, 13),
woosh.Token(woosh.NAME, 'cmp', 472, 13, 472, 16),
woosh.Token(woosh.OP, '=', 472, 17, 472, 18),
woosh.Token(woosh.NAME, 'self', 472, 19, 472, 23),
woosh.Token(woosh.OP, '.', 472, 23, 472, 24),
woosh.Token(woosh.NAME, 'zlib', 472, 24, 472, 28),
woosh.Token(woosh.OP, '.', 472, 28, 472, 29),
woosh.Token(woosh.NAME, 'decompressobj', 472, 29, 472, 42),
woosh.Token(woosh.OP, '(', 472, 42, 472, 43),
woosh.Token(woosh.OP, '-', 472, 43, 472, 44),
woosh.Token(woosh.NAME, 'self', 472, 44, 472, 48),
woosh.Token(woosh.OP, '.', 472, 48, 472, 49),
woosh.Token(woosh.NAME, 'zlib', 472, 49, 472, 53),
woosh.Token(woosh.OP, '.', 472, 53, 472, 54),
woosh.Token(woosh.NAME, 'MAX_WBITS', 472, 54, 472, 63),
woosh.Token(woosh.OP, ')', 472, 63, 472, 64),
woosh.Token(woosh.NEWLINE, '\r\n', 472, 64, 473, 0),
woosh.Token(woosh.NAME, 'self', 473, 8, 473, 12),
woosh.Token(woosh.OP, '.', 473, 12, 473, 13),
woosh.Token(woosh.NAME, 'dbuf', 473, 13, 473, 17),
woosh.Token(woosh.OP, '=', 473, 18, 473, 19),
woosh.Token(woosh.STRING, 'b""', 473, 20, 473, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 473, 23, 474, 0),
woosh.Token(woosh.COMMENT, '# taken from gzip.GzipFile with some alterations', 475, 8, 475, 56),
woosh.Token(woosh.NAME, 'if', 476, 8, 476, 10),
woosh.Token(woosh.NAME, 'self', 476, 11, 476, 15),
woosh.Token(woosh.OP, '.', 476, 15, 476, 16),
woosh.Token(woosh.NAME, '__read', 476, 16, 476, 22),
woosh.Token(woosh.OP, '(', 476, 22, 476, 23),
woosh.Token(woosh.NUMBER, '2', 476, 23, 476, 24),
woosh.Token(woosh.OP, ')', 476, 24, 476, 25),
woosh.Token(woosh.OP, '!=', 476, 26, 476, 28),
woosh.Token(woosh.STRING, 'b"\\037\\213"', 476, 29, 476, 40),
woosh.Token(woosh.OP, ':', 476, 40, 476, 41),
woosh.Token(woosh.NEWLINE, '\r\n', 476, 41, 477, 0),
woosh.Token(woosh.INDENT, ' ', 477, 0, 477, 12),
woosh.Token(woosh.NAME, 'raise', 477, 12, 477, 17),
woosh.Token(woosh.NAME, 'ReadError', 477, 18, 477, 27),
woosh.Token(woosh.OP, '(', 477, 27, 477, 28),
woosh.Token(woosh.STRING, '"not a gzip file"', 477, 28, 477, 45),
woosh.Token(woosh.OP, ')', 477, 45, 477, 46),
woosh.Token(woosh.NEWLINE, '\r\n', 477, 46, 478, 0),
woosh.Token(woosh.DEDENT, ' ', 478, 0, 478, 8),
woosh.Token(woosh.NAME, 'if', 478, 8, 478, 10),
woosh.Token(woosh.NAME, 'self', 478, 11, 478, 15),
woosh.Token(woosh.OP, '.', 478, 15, 478, 16),
woosh.Token(woosh.NAME, '__read', 478, 16, 478, 22),
woosh.Token(woosh.OP, '(', 478, 22, 478, 23),
woosh.Token(woosh.NUMBER, '1', 478, 23, 478, 24),
woosh.Token(woosh.OP, ')', 478, 24, 478, 25),
woosh.Token(woosh.OP, '!=', 478, 26, 478, 28),
woosh.Token(woosh.STRING, 'b"\\010"', 478, 29, 478, 36),
woosh.Token(woosh.OP, ':', 478, 36, 478, 37),
woosh.Token(woosh.NEWLINE, '\r\n', 478, 37, 479, 0),
woosh.Token(woosh.INDENT, ' ', 479, 0, 479, 12),
woosh.Token(woosh.NAME, 'raise', 479, 12, 479, 17),
woosh.Token(woosh.NAME, 'CompressionError', 479, 18, 479, 34),
woosh.Token(woosh.OP, '(', 479, 34, 479, 35),
woosh.Token(woosh.STRING, '"unsupported compression method"', 479, 35, 479, 67),
woosh.Token(woosh.OP, ')', 479, 67, 479, 68),
woosh.Token(woosh.NEWLINE, '\r\n', 479, 68, 480, 0),
woosh.Token(woosh.DEDENT, ' ', 481, 0, 481, 8),
woosh.Token(woosh.NAME, 'flag', 481, 8, 481, 12),
woosh.Token(woosh.OP, '=', 481, 13, 481, 14),
woosh.Token(woosh.NAME, 'ord', 481, 15, 481, 18),
woosh.Token(woosh.OP, '(', 481, 18, 481, 19),
woosh.Token(woosh.NAME, 'self', 481, 19, 481, 23),
woosh.Token(woosh.OP, '.', 481, 23, 481, 24),
woosh.Token(woosh.NAME, '__read', 481, 24, 481, 30),
woosh.Token(woosh.OP, '(', 481, 30, 481, 31),
woosh.Token(woosh.NUMBER, '1', 481, 31, 481, 32),
woosh.Token(woosh.OP, ')', 481, 32, 481, 33),
woosh.Token(woosh.OP, ')', 481, 33, 481, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 481, 34, 482, 0),
woosh.Token(woosh.NAME, 'self', 482, 8, 482, 12),
woosh.Token(woosh.OP, '.', 482, 12, 482, 13),
woosh.Token(woosh.NAME, '__read', 482, 13, 482, 19),
woosh.Token(woosh.OP, '(', 482, 19, 482, 20),
woosh.Token(woosh.NUMBER, '6', 482, 20, 482, 21),
woosh.Token(woosh.OP, ')', 482, 21, 482, 22),
woosh.Token(woosh.NEWLINE, '\r\n', 482, 22, 483, 0),
woosh.Token(woosh.NAME, 'if', 484, 8, 484, 10),
woosh.Token(woosh.NAME, 'flag', 484, 11, 484, 15),
woosh.Token(woosh.OP, '&', 484, 16, 484, 17),
woosh.Token(woosh.NUMBER, '4', 484, 18, 484, 19),
woosh.Token(woosh.OP, ':', 484, 19, 484, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 484, 20, 485, 0),
woosh.Token(woosh.INDENT, ' ', 485, 0, 485, 12),
woosh.Token(woosh.NAME, 'xlen', 485, 12, 485, 16),
woosh.Token(woosh.OP, '=', 485, 17, 485, 18),
woosh.Token(woosh.NAME, 'ord', 485, 19, 485, 22),
woosh.Token(woosh.OP, '(', 485, 22, 485, 23),
woosh.Token(woosh.NAME, 'self', 485, 23, 485, 27),
woosh.Token(woosh.OP, '.', 485, 27, 485, 28),
woosh.Token(woosh.NAME, '__read', 485, 28, 485, 34),
woosh.Token(woosh.OP, '(', 485, 34, 485, 35),
woosh.Token(woosh.NUMBER, '1', 485, 35, 485, 36),
woosh.Token(woosh.OP, ')', 485, 36, 485, 37),
woosh.Token(woosh.OP, ')', 485, 37, 485, 38),
woosh.Token(woosh.OP, '+', 485, 39, 485, 40),
woosh.Token(woosh.NUMBER, '256', 485, 41, 485, 44),
woosh.Token(woosh.OP, '*', 485, 45, 485, 46),
woosh.Token(woosh.NAME, 'ord', 485, 47, 485, 50),
woosh.Token(woosh.OP, '(', 485, 50, 485, 51),
woosh.Token(woosh.NAME, 'self', 485, 51, 485, 55),
woosh.Token(woosh.OP, '.', 485, 55, 485, 56),
woosh.Token(woosh.NAME, '__read', 485, 56, 485, 62),
woosh.Token(woosh.OP, '(', 485, 62, 485, 63),
woosh.Token(woosh.NUMBER, '1', 485, 63, 485, 64),
woosh.Token(woosh.OP, ')', 485, 64, 485, 65),
woosh.Token(woosh.OP, ')', 485, 65, 485, 66),
woosh.Token(woosh.NEWLINE, '\r\n', 485, 66, 486, 0),
woosh.Token(woosh.NAME, 'self', 486, 12, 486, 16),
woosh.Token(woosh.OP, '.', 486, 16, 486, 17),
woosh.Token(woosh.NAME, 'read', 486, 17, 486, 21),
woosh.Token(woosh.OP, '(', 486, 21, 486, 22),
woosh.Token(woosh.NAME, 'xlen', 486, 22, 486, 26),
woosh.Token(woosh.OP, ')', 486, 26, 486, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 486, 27, 487, 0),
woosh.Token(woosh.DEDENT, ' ', 487, 0, 487, 8),
woosh.Token(woosh.NAME, 'if', 487, 8, 487, 10),
woosh.Token(woosh.NAME, 'flag', 487, 11, 487, 15),
woosh.Token(woosh.OP, '&', 487, 16, 487, 17),
woosh.Token(woosh.NUMBER, '8', 487, 18, 487, 19),
woosh.Token(woosh.OP, ':', 487, 19, 487, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 487, 20, 488, 0),
woosh.Token(woosh.INDENT, ' ', 488, 0, 488, 12),
woosh.Token(woosh.NAME, 'while', 488, 12, 488, 17),
woosh.Token(woosh.NAME, 'True', 488, 18, 488, 22),
woosh.Token(woosh.OP, ':', 488, 22, 488, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 488, 23, 489, 0),
woosh.Token(woosh.INDENT, ' ', 489, 0, 489, 16),
woosh.Token(woosh.NAME, 's', 489, 16, 489, 17),
woosh.Token(woosh.OP, '=', 489, 18, 489, 19),
woosh.Token(woosh.NAME, 'self', 489, 20, 489, 24),
woosh.Token(woosh.OP, '.', 489, 24, 489, 25),
woosh.Token(woosh.NAME, '__read', 489, 25, 489, 31),
woosh.Token(woosh.OP, '(', 489, 31, 489, 32),
woosh.Token(woosh.NUMBER, '1', 489, 32, 489, 33),
woosh.Token(woosh.OP, ')', 489, 33, 489, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 489, 34, 490, 0),
woosh.Token(woosh.NAME, 'if', 490, 16, 490, 18),
woosh.Token(woosh.NAME, 'not', 490, 19, 490, 22),
woosh.Token(woosh.NAME, 's', 490, 23, 490, 24),
woosh.Token(woosh.NAME, 'or', 490, 25, 490, 27),
woosh.Token(woosh.NAME, 's', 490, 28, 490, 29),
woosh.Token(woosh.OP, '==', 490, 30, 490, 32),
woosh.Token(woosh.NAME, 'NUL', 490, 33, 490, 36),
woosh.Token(woosh.OP, ':', 490, 36, 490, 37),
woosh.Token(woosh.NEWLINE, '\r\n', 490, 37, 491, 0),
woosh.Token(woosh.INDENT, ' ', 491, 0, 491, 20),
woosh.Token(woosh.NAME, 'break', 491, 20, 491, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 491, 25, 492, 0),
woosh.Token(woosh.DEDENT, ' ', 492, 0, 492, 8),
woosh.Token(woosh.DEDENT, '', 492, 8, 492, 8),
woosh.Token(woosh.DEDENT, '', 492, 8, 492, 8),
woosh.Token(woosh.NAME, 'if', 492, 8, 492, 10),
woosh.Token(woosh.NAME, 'flag', 492, 11, 492, 15),
woosh.Token(woosh.OP, '&', 492, 16, 492, 17),
woosh.Token(woosh.NUMBER, '16', 492, 18, 492, 20),
woosh.Token(woosh.OP, ':', 492, 20, 492, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 492, 21, 493, 0),
woosh.Token(woosh.INDENT, ' ', 493, 0, 493, 12),
woosh.Token(woosh.NAME, 'while', 493, 12, 493, 17),
woosh.Token(woosh.NAME, 'True', 493, 18, 493, 22),
woosh.Token(woosh.OP, ':', 493, 22, 493, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 493, 23, 494, 0),
woosh.Token(woosh.INDENT, ' ', 494, 0, 494, 16),
woosh.Token(woosh.NAME, 's', 494, 16, 494, 17),
woosh.Token(woosh.OP, '=', 494, 18, 494, 19),
woosh.Token(woosh.NAME, 'self', 494, 20, 494, 24),
woosh.Token(woosh.OP, '.', 494, 24, 494, 25),
woosh.Token(woosh.NAME, '__read', 494, 25, 494, 31),
woosh.Token(woosh.OP, '(', 494, 31, 494, 32),
woosh.Token(woosh.NUMBER, '1', 494, 32, 494, 33),
woosh.Token(woosh.OP, ')', 494, 33, 494, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 494, 34, 495, 0),
woosh.Token(woosh.NAME, 'if', 495, 16, 495, 18),
woosh.Token(woosh.NAME, 'not', 495, 19, 495, 22),
woosh.Token(woosh.NAME, 's', 495, 23, 495, 24),
woosh.Token(woosh.NAME, 'or', 495, 25, 495, 27),
woosh.Token(woosh.NAME, 's', 495, 28, 495, 29),
woosh.Token(woosh.OP, '==', 495, 30, 495, 32),
woosh.Token(woosh.NAME, 'NUL', 495, 33, 495, 36),
woosh.Token(woosh.OP, ':', 495, 36, 495, 37),
woosh.Token(woosh.NEWLINE, '\r\n', 495, 37, 496, 0),
woosh.Token(woosh.INDENT, ' ', 496, 0, 496, 20),
woosh.Token(woosh.NAME, 'break', 496, 20, 496, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 496, 25, 497, 0),
woosh.Token(woosh.DEDENT, ' ', 497, 0, 497, 8),
woosh.Token(woosh.DEDENT, '', 497, 8, 497, 8),
woosh.Token(woosh.DEDENT, '', 497, 8, 497, 8),
woosh.Token(woosh.NAME, 'if', 497, 8, 497, 10),
woosh.Token(woosh.NAME, 'flag', 497, 11, 497, 15),
woosh.Token(woosh.OP, '&', 497, 16, 497, 17),
woosh.Token(woosh.NUMBER, '2', 497, 18, 497, 19),
woosh.Token(woosh.OP, ':', 497, 19, 497, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 497, 20, 498, 0),
woosh.Token(woosh.INDENT, ' ', 498, 0, 498, 12),
woosh.Token(woosh.NAME, 'self', 498, 12, 498, 16),
woosh.Token(woosh.OP, '.', 498, 16, 498, 17),
woosh.Token(woosh.NAME, '__read', 498, 17, 498, 23),
woosh.Token(woosh.OP, '(', 498, 23, 498, 24),
woosh.Token(woosh.NUMBER, '2', 498, 24, 498, 25),
woosh.Token(woosh.OP, ')', 498, 25, 498, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 498, 26, 499, 0),
woosh.Token(woosh.DEDENT, ' ', 500, 0, 500, 4),
woosh.Token(woosh.DEDENT, '', 500, 4, 500, 4),
woosh.Token(woosh.NAME, 'def', 500, 4, 500, 7),
woosh.Token(woosh.NAME, 'tell', 500, 8, 500, 12),
woosh.Token(woosh.OP, '(', 500, 12, 500, 13),
woosh.Token(woosh.NAME, 'self', 500, 13, 500, 17),
woosh.Token(woosh.OP, ')', 500, 17, 500, 18),
woosh.Token(woosh.OP, ':', 500, 18, 500, 19),
woosh.Token(woosh.NEWLINE, '\r\n', 500, 19, 501, 0),
woosh.Token(woosh.INDENT, ' ', 501, 0, 501, 8),
woosh.Token(woosh.STRING, '"""Return the stream\'s file pointer position.\r\n """', 501, 8, 502, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 502, 11, 503, 0),
woosh.Token(woosh.NAME, 'return', 503, 8, 503, 14),
woosh.Token(woosh.NAME, 'self', 503, 15, 503, 19),
woosh.Token(woosh.OP, '.', 503, 19, 503, 20),
woosh.Token(woosh.NAME, 'pos', 503, 20, 503, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 503, 23, 504, 0),
woosh.Token(woosh.DEDENT, ' ', 505, 0, 505, 4),
woosh.Token(woosh.NAME, 'def', 505, 4, 505, 7),
woosh.Token(woosh.NAME, 'seek', 505, 8, 505, 12),
woosh.Token(woosh.OP, '(', 505, 12, 505, 13),
woosh.Token(woosh.NAME, 'self', 505, 13, 505, 17),
woosh.Token(woosh.OP, ',', 505, 17, 505, 18),
woosh.Token(woosh.NAME, 'pos', 505, 19, 505, 22),
woosh.Token(woosh.OP, '=', 505, 22, 505, 23),
woosh.Token(woosh.NUMBER, '0', 505, 23, 505, 24),
woosh.Token(woosh.OP, ')', 505, 24, 505, 25),
woosh.Token(woosh.OP, ':', 505, 25, 505, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 505, 26, 506, 0),
woosh.Token(woosh.INDENT, ' ', 506, 0, 506, 8),
woosh.Token(woosh.STRING, '"""Set the stream\'s file pointer to pos. Negative seeking\r\n is forbidden.\r\n """', 506, 8, 508, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 508, 11, 509, 0),
woosh.Token(woosh.NAME, 'if', 509, 8, 509, 10),
woosh.Token(woosh.NAME, 'pos', 509, 11, 509, 14),
woosh.Token(woosh.OP, '-', 509, 15, 509, 16),
woosh.Token(woosh.NAME, 'self', 509, 17, 509, 21),
woosh.Token(woosh.OP, '.', 509, 21, 509, 22),
woosh.Token(woosh.NAME, 'pos', 509, 22, 509, 25),
woosh.Token(woosh.OP, '>=', 509, 26, 509, 28),
woosh.Token(woosh.NUMBER, '0', 509, 29, 509, 30),
woosh.Token(woosh.OP, ':', 509, 30, 509, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 509, 31, 510, 0),
woosh.Token(woosh.INDENT, ' ', 510, 0, 510, 12),
woosh.Token(woosh.NAME, 'blocks', 510, 12, 510, 18),
woosh.Token(woosh.OP, ',', 510, 18, 510, 19),
woosh.Token(woosh.NAME, 'remainder', 510, 20, 510, 29),
woosh.Token(woosh.OP, '=', 510, 30, 510, 31),
woosh.Token(woosh.NAME, 'divmod', 510, 32, 510, 38),
woosh.Token(woosh.OP, '(', 510, 38, 510, 39),
woosh.Token(woosh.NAME, 'pos', 510, 39, 510, 42),
woosh.Token(woosh.OP, '-', 510, 43, 510, 44),
woosh.Token(woosh.NAME, 'self', 510, 45, 510, 49),
woosh.Token(woosh.OP, '.', 510, 49, 510, 50),
woosh.Token(woosh.NAME, 'pos', 510, 50, 510, 53),
woosh.Token(woosh.OP, ',', 510, 53, 510, 54),
woosh.Token(woosh.NAME, 'self', 510, 55, 510, 59),
woosh.Token(woosh.OP, '.', 510, 59, 510, 60),
woosh.Token(woosh.NAME, 'bufsize', 510, 60, 510, 67),
woosh.Token(woosh.OP, ')', 510, 67, 510, 68),
woosh.Token(woosh.NEWLINE, '\r\n', 510, 68, 511, 0),
woosh.Token(woosh.NAME, 'for', 511, 12, 511, 15),
woosh.Token(woosh.NAME, 'i', 511, 16, 511, 17),
woosh.Token(woosh.NAME, 'in', 511, 18, 511, 20),
woosh.Token(woosh.NAME, 'range', 511, 21, 511, 26),
woosh.Token(woosh.OP, '(', 511, 26, 511, 27),
woosh.Token(woosh.NAME, 'blocks', 511, 27, 511, 33),
woosh.Token(woosh.OP, ')', 511, 33, 511, 34),
woosh.Token(woosh.OP, ':', 511, 34, 511, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 511, 35, 512, 0),
woosh.Token(woosh.INDENT, ' ', 512, 0, 512, 16),
woosh.Token(woosh.NAME, 'self', 512, 16, 512, 20),
woosh.Token(woosh.OP, '.', 512, 20, 512, 21),
woosh.Token(woosh.NAME, 'read', 512, 21, 512, 25),
woosh.Token(woosh.OP, '(', 512, 25, 512, 26),
woosh.Token(woosh.NAME, 'self', 512, 26, 512, 30),
woosh.Token(woosh.OP, '.', 512, 30, 512, 31),
woosh.Token(woosh.NAME, 'bufsize', 512, 31, 512, 38),
woosh.Token(woosh.OP, ')', 512, 38, 512, 39),
woosh.Token(woosh.NEWLINE, '\r\n', 512, 39, 513, 0),
woosh.Token(woosh.DEDENT, ' ', 513, 0, 513, 12),
woosh.Token(woosh.NAME, 'self', 513, 12, 513, 16),
woosh.Token(woosh.OP, '.', 513, 16, 513, 17),
woosh.Token(woosh.NAME, 'read', 513, 17, 513, 21),
woosh.Token(woosh.OP, '(', 513, 21, 513, 22),
woosh.Token(woosh.NAME, 'remainder', 513, 22, 513, 31),
woosh.Token(woosh.OP, ')', 513, 31, 513, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 513, 32, 514, 0),
woosh.Token(woosh.DEDENT, ' ', 514, 0, 514, 8),
woosh.Token(woosh.NAME, 'else', 514, 8, 514, 12),
woosh.Token(woosh.OP, ':', 514, 12, 514, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 514, 13, 515, 0),
woosh.Token(woosh.INDENT, ' ', 515, 0, 515, 12),
woosh.Token(woosh.NAME, 'raise', 515, 12, 515, 17),
woosh.Token(woosh.NAME, 'StreamError', 515, 18, 515, 29),
woosh.Token(woosh.OP, '(', 515, 29, 515, 30),
woosh.Token(woosh.STRING, '"seeking backwards is not allowed"', 515, 30, 515, 64),
woosh.Token(woosh.OP, ')', 515, 64, 515, 65),
woosh.Token(woosh.NEWLINE, '\r\n', 515, 65, 516, 0),
woosh.Token(woosh.DEDENT, ' ', 516, 0, 516, 8),
woosh.Token(woosh.NAME, 'return', 516, 8, 516, 14),
woosh.Token(woosh.NAME, 'self', 516, 15, 516, 19),
woosh.Token(woosh.OP, '.', 516, 19, 516, 20),
woosh.Token(woosh.NAME, 'pos', 516, 20, 516, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 516, 23, 517, 0),
woosh.Token(woosh.DEDENT, ' ', 518, 0, 518, 4),
woosh.Token(woosh.NAME, 'def', 518, 4, 518, 7),
woosh.Token(woosh.NAME, 'read', 518, 8, 518, 12),
woosh.Token(woosh.OP, '(', 518, 12, 518, 13),
woosh.Token(woosh.NAME, 'self', 518, 13, 518, 17),
woosh.Token(woosh.OP, ',', 518, 17, 518, 18),
woosh.Token(woosh.NAME, 'size', 518, 19, 518, 23),
woosh.Token(woosh.OP, ')', 518, 23, 518, 24),
woosh.Token(woosh.OP, ':', 518, 24, 518, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 518, 25, 519, 0),
woosh.Token(woosh.INDENT, ' ', 519, 0, 519, 8),
woosh.Token(woosh.STRING, '"""Return the next size number of bytes from the stream."""', 519, 8, 519, 67),
woosh.Token(woosh.NEWLINE, '\r\n', 519, 67, 520, 0),
woosh.Token(woosh.NAME, 'assert', 520, 8, 520, 14),
woosh.Token(woosh.NAME, 'size', 520, 15, 520, 19),
woosh.Token(woosh.NAME, 'is', 520, 20, 520, 22),
woosh.Token(woosh.NAME, 'not', 520, 23, 520, 26),
woosh.Token(woosh.NAME, 'None', 520, 27, 520, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 520, 31, 521, 0),
woosh.Token(woosh.NAME, 'buf', 521, 8, 521, 11),
woosh.Token(woosh.OP, '=', 521, 12, 521, 13),
woosh.Token(woosh.NAME, 'self', 521, 14, 521, 18),
woosh.Token(woosh.OP, '.', 521, 18, 521, 19),
woosh.Token(woosh.NAME, '_read', 521, 19, 521, 24),
woosh.Token(woosh.OP, '(', 521, 24, 521, 25),
woosh.Token(woosh.NAME, 'size', 521, 25, 521, 29),
woosh.Token(woosh.OP, ')', 521, 29, 521, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 521, 30, 522, 0),
woosh.Token(woosh.NAME, 'self', 522, 8, 522, 12),
woosh.Token(woosh.OP, '.', 522, 12, 522, 13),
woosh.Token(woosh.NAME, 'pos', 522, 13, 522, 16),
woosh.Token(woosh.OP, '+=', 522, 17, 522, 19),
woosh.Token(woosh.NAME, 'len', 522, 20, 522, 23),
woosh.Token(woosh.OP, '(', 522, 23, 522, 24),
woosh.Token(woosh.NAME, 'buf', 522, 24, 522, 27),
woosh.Token(woosh.OP, ')', 522, 27, 522, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 522, 28, 523, 0),
woosh.Token(woosh.NAME, 'return', 523, 8, 523, 14),
woosh.Token(woosh.NAME, 'buf', 523, 15, 523, 18),
woosh.Token(woosh.NEWLINE, '\r\n', 523, 18, 524, 0),
woosh.Token(woosh.DEDENT, ' ', 525, 0, 525, 4),
woosh.Token(woosh.NAME, 'def', 525, 4, 525, 7),
woosh.Token(woosh.NAME, '_read', 525, 8, 525, 13),
woosh.Token(woosh.OP, '(', 525, 13, 525, 14),
woosh.Token(woosh.NAME, 'self', 525, 14, 525, 18),
woosh.Token(woosh.OP, ',', 525, 18, 525, 19),
woosh.Token(woosh.NAME, 'size', 525, 20, 525, 24),
woosh.Token(woosh.OP, ')', 525, 24, 525, 25),
woosh.Token(woosh.OP, ':', 525, 25, 525, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 525, 26, 526, 0),
woosh.Token(woosh.INDENT, ' ', 526, 0, 526, 8),
woosh.Token(woosh.STRING, '"""Return size bytes from the stream.\r\n """', 526, 8, 527, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 527, 11, 528, 0),
woosh.Token(woosh.NAME, 'if', 528, 8, 528, 10),
woosh.Token(woosh.NAME, 'self', 528, 11, 528, 15),
woosh.Token(woosh.OP, '.', 528, 15, 528, 16),
woosh.Token(woosh.NAME, 'comptype', 528, 16, 528, 24),
woosh.Token(woosh.OP, '==', 528, 25, 528, 27),
woosh.Token(woosh.STRING, '"tar"', 528, 28, 528, 33),
woosh.Token(woosh.OP, ':', 528, 33, 528, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 528, 34, 529, 0),
woosh.Token(woosh.INDENT, ' ', 529, 0, 529, 12),
woosh.Token(woosh.NAME, 'return', 529, 12, 529, 18),
woosh.Token(woosh.NAME, 'self', 529, 19, 529, 23),
woosh.Token(woosh.OP, '.', 529, 23, 529, 24),
woosh.Token(woosh.NAME, '__read', 529, 24, 529, 30),
woosh.Token(woosh.OP, '(', 529, 30, 529, 31),
woosh.Token(woosh.NAME, 'size', 529, 31, 529, 35),
woosh.Token(woosh.OP, ')', 529, 35, 529, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 529, 36, 530, 0),
woosh.Token(woosh.DEDENT, ' ', 531, 0, 531, 8),
woosh.Token(woosh.NAME, 'c', 531, 8, 531, 9),
woosh.Token(woosh.OP, '=', 531, 10, 531, 11),
woosh.Token(woosh.NAME, 'len', 531, 12, 531, 15),
woosh.Token(woosh.OP, '(', 531, 15, 531, 16),
woosh.Token(woosh.NAME, 'self', 531, 16, 531, 20),
woosh.Token(woosh.OP, '.', 531, 20, 531, 21),
woosh.Token(woosh.NAME, 'dbuf', 531, 21, 531, 25),
woosh.Token(woosh.OP, ')', 531, 25, 531, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 531, 26, 532, 0),
woosh.Token(woosh.NAME, 't', 532, 8, 532, 9),
woosh.Token(woosh.OP, '=', 532, 10, 532, 11),
woosh.Token(woosh.OP, '[', 532, 12, 532, 13),
woosh.Token(woosh.NAME, 'self', 532, 13, 532, 17),
woosh.Token(woosh.OP, '.', 532, 17, 532, 18),
woosh.Token(woosh.NAME, 'dbuf', 532, 18, 532, 22),
woosh.Token(woosh.OP, ']', 532, 22, 532, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 532, 23, 533, 0),
woosh.Token(woosh.NAME, 'while', 533, 8, 533, 13),
woosh.Token(woosh.NAME, 'c', 533, 14, 533, 15),
woosh.Token(woosh.OP, '<', 533, 16, 533, 17),
woosh.Token(woosh.NAME, 'size', 533, 18, 533, 22),
woosh.Token(woosh.OP, ':', 533, 22, 533, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 533, 23, 534, 0),
woosh.Token(woosh.COMMENT, '# Skip underlying buffer to avoid unaligned double buffering.', 534, 12, 534, 73),
woosh.Token(woosh.INDENT, ' ', 535, 0, 535, 12),
woosh.Token(woosh.NAME, 'if', 535, 12, 535, 14),
woosh.Token(woosh.NAME, 'self', 535, 15, 535, 19),
woosh.Token(woosh.OP, '.', 535, 19, 535, 20),
woosh.Token(woosh.NAME, 'buf', 535, 20, 535, 23),
woosh.Token(woosh.OP, ':', 535, 23, 535, 24),
woosh.Token(woosh.NEWLINE, '\r\n', 535, 24, 536, 0),
woosh.Token(woosh.INDENT, ' ', 536, 0, 536, 16),
woosh.Token(woosh.NAME, 'buf', 536, 16, 536, 19),
woosh.Token(woosh.OP, '=', 536, 20, 536, 21),
woosh.Token(woosh.NAME, 'self', 536, 22, 536, 26),
woosh.Token(woosh.OP, '.', 536, 26, 536, 27),
woosh.Token(woosh.NAME, 'buf', 536, 27, 536, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 536, 30, 537, 0),
woosh.Token(woosh.NAME, 'self', 537, 16, 537, 20),
woosh.Token(woosh.OP, '.', 537, 20, 537, 21),
woosh.Token(woosh.NAME, 'buf', 537, 21, 537, 24),
woosh.Token(woosh.OP, '=', 537, 25, 537, 26),
woosh.Token(woosh.STRING, 'b""', 537, 27, 537, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 537, 30, 538, 0),
woosh.Token(woosh.DEDENT, ' ', 538, 0, 538, 12),
woosh.Token(woosh.NAME, 'else', 538, 12, 538, 16),
woosh.Token(woosh.OP, ':', 538, 16, 538, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 538, 17, 539, 0),
woosh.Token(woosh.INDENT, ' ', 539, 0, 539, 16),
woosh.Token(woosh.NAME, 'buf', 539, 16, 539, 19),
woosh.Token(woosh.OP, '=', 539, 20, 539, 21),
woosh.Token(woosh.NAME, 'self', 539, 22, 539, 26),
woosh.Token(woosh.OP, '.', 539, 26, 539, 27),
woosh.Token(woosh.NAME, 'fileobj', 539, 27, 539, 34),
woosh.Token(woosh.OP, '.', 539, 34, 539, 35),
woosh.Token(woosh.NAME, 'read', 539, 35, 539, 39),
woosh.Token(woosh.OP, '(', 539, 39, 539, 40),
woosh.Token(woosh.NAME, 'self', 539, 40, 539, 44),
woosh.Token(woosh.OP, '.', 539, 44, 539, 45),
woosh.Token(woosh.NAME, 'bufsize', 539, 45, 539, 52),
woosh.Token(woosh.OP, ')', 539, 52, 539, 53),
woosh.Token(woosh.NEWLINE, '\r\n', 539, 53, 540, 0),
woosh.Token(woosh.NAME, 'if', 540, 16, 540, 18),
woosh.Token(woosh.NAME, 'not', 540, 19, 540, 22),
woosh.Token(woosh.NAME, 'buf', 540, 23, 540, 26),
woosh.Token(woosh.OP, ':', 540, 26, 540, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 540, 27, 541, 0),
woosh.Token(woosh.INDENT, ' ', 541, 0, 541, 20),
woosh.Token(woosh.NAME, 'break', 541, 20, 541, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 541, 25, 542, 0),
woosh.Token(woosh.DEDENT, ' ', 542, 0, 542, 12),
woosh.Token(woosh.DEDENT, '', 542, 12, 542, 12),
woosh.Token(woosh.NAME, 'try', 542, 12, 542, 15),
woosh.Token(woosh.OP, ':', 542, 15, 542, 16),
woosh.Token(woosh.NEWLINE, '\r\n', 542, 16, 543, 0),
woosh.Token(woosh.INDENT, ' ', 543, 0, 543, 16),
woosh.Token(woosh.NAME, 'buf', 543, 16, 543, 19),
woosh.Token(woosh.OP, '=', 543, 20, 543, 21),
woosh.Token(woosh.NAME, 'self', 543, 22, 543, 26),
woosh.Token(woosh.OP, '.', 543, 26, 543, 27),
woosh.Token(woosh.NAME, 'cmp', 543, 27, 543, 30),
woosh.Token(woosh.OP, '.', 543, 30, 543, 31),
woosh.Token(woosh.NAME, 'decompress', 543, 31, 543, 41),
woosh.Token(woosh.OP, '(', 543, 41, 543, 42),
woosh.Token(woosh.NAME, 'buf', 543, 42, 543, 45),
woosh.Token(woosh.OP, ')', 543, 45, 543, 46),
woosh.Token(woosh.NEWLINE, '\r\n', 543, 46, 544, 0),
woosh.Token(woosh.DEDENT, ' ', 544, 0, 544, 12),
woosh.Token(woosh.NAME, 'except', 544, 12, 544, 18),
woosh.Token(woosh.NAME, 'self', 544, 19, 544, 23),
woosh.Token(woosh.OP, '.', 544, 23, 544, 24),
woosh.Token(woosh.NAME, 'exception', 544, 24, 544, 33),
woosh.Token(woosh.OP, ':', 544, 33, 544, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 544, 34, 545, 0),
woosh.Token(woosh.INDENT, ' ', 545, 0, 545, 16),
woosh.Token(woosh.NAME, 'raise', 545, 16, 545, 21),
woosh.Token(woosh.NAME, 'ReadError', 545, 22, 545, 31),
woosh.Token(woosh.OP, '(', 545, 31, 545, 32),
woosh.Token(woosh.STRING, '"invalid compressed data"', 545, 32, 545, 57),
woosh.Token(woosh.OP, ')', 545, 57, 545, 58),
woosh.Token(woosh.NEWLINE, '\r\n', 545, 58, 546, 0),
woosh.Token(woosh.DEDENT, ' ', 546, 0, 546, 12),
woosh.Token(woosh.NAME, 't', 546, 12, 546, 13),
woosh.Token(woosh.OP, '.', 546, 13, 546, 14),
woosh.Token(woosh.NAME, 'append', 546, 14, 546, 20),
woosh.Token(woosh.OP, '(', 546, 20, 546, 21),
woosh.Token(woosh.NAME, 'buf', 546, 21, 546, 24),
woosh.Token(woosh.OP, ')', 546, 24, 546, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 546, 25, 547, 0),
woosh.Token(woosh.NAME, 'c', 547, 12, 547, 13),
woosh.Token(woosh.OP, '+=', 547, 14, 547, 16),
woosh.Token(woosh.NAME, 'len', 547, 17, 547, 20),
woosh.Token(woosh.OP, '(', 547, 20, 547, 21),
woosh.Token(woosh.NAME, 'buf', 547, 21, 547, 24),
woosh.Token(woosh.OP, ')', 547, 24, 547, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 547, 25, 548, 0),
woosh.Token(woosh.DEDENT, ' ', 548, 0, 548, 8),
woosh.Token(woosh.NAME, 't', 548, 8, 548, 9),
woosh.Token(woosh.OP, '=', 548, 10, 548, 11),
woosh.Token(woosh.STRING, 'b""', 548, 12, 548, 15),
woosh.Token(woosh.OP, '.', 548, 15, 548, 16),
woosh.Token(woosh.NAME, 'join', 548, 16, 548, 20),
woosh.Token(woosh.OP, '(', 548, 20, 548, 21),
woosh.Token(woosh.NAME, 't', 548, 21, 548, 22),
woosh.Token(woosh.OP, ')', 548, 22, 548, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 548, 23, 549, 0),
woosh.Token(woosh.NAME, 'self', 549, 8, 549, 12),
woosh.Token(woosh.OP, '.', 549, 12, 549, 13),
woosh.Token(woosh.NAME, 'dbuf', 549, 13, 549, 17),
woosh.Token(woosh.OP, '=', 549, 18, 549, 19),
woosh.Token(woosh.NAME, 't', 549, 20, 549, 21),
woosh.Token(woosh.OP, '[', 549, 21, 549, 22),
woosh.Token(woosh.NAME, 'size', 549, 22, 549, 26),
woosh.Token(woosh.OP, ':', 549, 26, 549, 27),
woosh.Token(woosh.OP, ']', 549, 27, 549, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 549, 28, 550, 0),
woosh.Token(woosh.NAME, 'return', 550, 8, 550, 14),
woosh.Token(woosh.NAME, 't', 550, 15, 550, 16),
woosh.Token(woosh.OP, '[', 550, 16, 550, 17),
woosh.Token(woosh.OP, ':', 550, 17, 550, 18),
woosh.Token(woosh.NAME, 'size', 550, 18, 550, 22),
woosh.Token(woosh.OP, ']', 550, 22, 550, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 550, 23, 551, 0),
woosh.Token(woosh.DEDENT, ' ', 552, 0, 552, 4),
woosh.Token(woosh.NAME, 'def', 552, 4, 552, 7),
woosh.Token(woosh.NAME, '__read', 552, 8, 552, 14),
woosh.Token(woosh.OP, '(', 552, 14, 552, 15),
woosh.Token(woosh.NAME, 'self', 552, 15, 552, 19),
woosh.Token(woosh.OP, ',', 552, 19, 552, 20),
woosh.Token(woosh.NAME, 'size', 552, 21, 552, 25),
woosh.Token(woosh.OP, ')', 552, 25, 552, 26),
woosh.Token(woosh.OP, ':', 552, 26, 552, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 552, 27, 553, 0),
woosh.Token(woosh.INDENT, ' ', 553, 0, 553, 8),
woosh.Token(woosh.STRING, '"""Return size bytes from stream. If internal buffer is empty,\r\n read another block from the stream.\r\n """', 553, 8, 555, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 555, 11, 556, 0),
woosh.Token(woosh.NAME, 'c', 556, 8, 556, 9),
woosh.Token(woosh.OP, '=', 556, 10, 556, 11),
woosh.Token(woosh.NAME, 'len', 556, 12, 556, 15),
woosh.Token(woosh.OP, '(', 556, 15, 556, 16),
woosh.Token(woosh.NAME, 'self', 556, 16, 556, 20),
woosh.Token(woosh.OP, '.', 556, 20, 556, 21),
woosh.Token(woosh.NAME, 'buf', 556, 21, 556, 24),
woosh.Token(woosh.OP, ')', 556, 24, 556, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 556, 25, 557, 0),
woosh.Token(woosh.NAME, 't', 557, 8, 557, 9),
woosh.Token(woosh.OP, '=', 557, 10, 557, 11),
woosh.Token(woosh.OP, '[', 557, 12, 557, 13),
woosh.Token(woosh.NAME, 'self', 557, 13, 557, 17),
woosh.Token(woosh.OP, '.', 557, 17, 557, 18),
woosh.Token(woosh.NAME, 'buf', 557, 18, 557, 21),
woosh.Token(woosh.OP, ']', 557, 21, 557, 22),
woosh.Token(woosh.NEWLINE, '\r\n', 557, 22, 558, 0),
woosh.Token(woosh.NAME, 'while', 558, 8, 558, 13),
woosh.Token(woosh.NAME, 'c', 558, 14, 558, 15),
woosh.Token(woosh.OP, '<', 558, 16, 558, 17),
woosh.Token(woosh.NAME, 'size', 558, 18, 558, 22),
woosh.Token(woosh.OP, ':', 558, 22, 558, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 558, 23, 559, 0),
woosh.Token(woosh.INDENT, ' ', 559, 0, 559, 12),
woosh.Token(woosh.NAME, 'buf', 559, 12, 559, 15),
woosh.Token(woosh.OP, '=', 559, 16, 559, 17),
woosh.Token(woosh.NAME, 'self', 559, 18, 559, 22),
woosh.Token(woosh.OP, '.', 559, 22, 559, 23),
woosh.Token(woosh.NAME, 'fileobj', 559, 23, 559, 30),
woosh.Token(woosh.OP, '.', 559, 30, 559, 31),
woosh.Token(woosh.NAME, 'read', 559, 31, 559, 35),
woosh.Token(woosh.OP, '(', 559, 35, 559, 36),
woosh.Token(woosh.NAME, 'self', 559, 36, 559, 40),
woosh.Token(woosh.OP, '.', 559, 40, 559, 41),
woosh.Token(woosh.NAME, 'bufsize', 559, 41, 559, 48),
woosh.Token(woosh.OP, ')', 559, 48, 559, 49),
woosh.Token(woosh.NEWLINE, '\r\n', 559, 49, 560, 0),
woosh.Token(woosh.NAME, 'if', 560, 12, 560, 14),
woosh.Token(woosh.NAME, 'not', 560, 15, 560, 18),
woosh.Token(woosh.NAME, 'buf', 560, 19, 560, 22),
woosh.Token(woosh.OP, ':', 560, 22, 560, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 560, 23, 561, 0),
woosh.Token(woosh.INDENT, ' ', 561, 0, 561, 16),
woosh.Token(woosh.NAME, 'break', 561, 16, 561, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 561, 21, 562, 0),
woosh.Token(woosh.DEDENT, ' ', 562, 0, 562, 12),
woosh.Token(woosh.NAME, 't', 562, 12, 562, 13),
woosh.Token(woosh.OP, '.', 562, 13, 562, 14),
woosh.Token(woosh.NAME, 'append', 562, 14, 562, 20),
woosh.Token(woosh.OP, '(', 562, 20, 562, 21),
woosh.Token(woosh.NAME, 'buf', 562, 21, 562, 24),
woosh.Token(woosh.OP, ')', 562, 24, 562, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 562, 25, 563, 0),
woosh.Token(woosh.NAME, 'c', 563, 12, 563, 13),
woosh.Token(woosh.OP, '+=', 563, 14, 563, 16),
woosh.Token(woosh.NAME, 'len', 563, 17, 563, 20),
woosh.Token(woosh.OP, '(', 563, 20, 563, 21),
woosh.Token(woosh.NAME, 'buf', 563, 21, 563, 24),
woosh.Token(woosh.OP, ')', 563, 24, 563, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 563, 25, 564, 0),
woosh.Token(woosh.DEDENT, ' ', 564, 0, 564, 8),
woosh.Token(woosh.NAME, 't', 564, 8, 564, 9),
woosh.Token(woosh.OP, '=', 564, 10, 564, 11),
woosh.Token(woosh.STRING, 'b""', 564, 12, 564, 15),
woosh.Token(woosh.OP, '.', 564, 15, 564, 16),
woosh.Token(woosh.NAME, 'join', 564, 16, 564, 20),
woosh.Token(woosh.OP, '(', 564, 20, 564, 21),
woosh.Token(woosh.NAME, 't', 564, 21, 564, 22),
woosh.Token(woosh.OP, ')', 564, 22, 564, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 564, 23, 565, 0),
woosh.Token(woosh.NAME, 'self', 565, 8, 565, 12),
woosh.Token(woosh.OP, '.', 565, 12, 565, 13),
woosh.Token(woosh.NAME, 'buf', 565, 13, 565, 16),
woosh.Token(woosh.OP, '=', 565, 17, 565, 18),
woosh.Token(woosh.NAME, 't', 565, 19, 565, 20),
woosh.Token(woosh.OP, '[', 565, 20, 565, 21),
woosh.Token(woosh.NAME, 'size', 565, 21, 565, 25),
woosh.Token(woosh.OP, ':', 565, 25, 565, 26),
woosh.Token(woosh.OP, ']', 565, 26, 565, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 565, 27, 566, 0),
woosh.Token(woosh.NAME, 'return', 566, 8, 566, 14),
woosh.Token(woosh.NAME, 't', 566, 15, 566, 16),
woosh.Token(woosh.OP, '[', 566, 16, 566, 17),
woosh.Token(woosh.OP, ':', 566, 17, 566, 18),
woosh.Token(woosh.NAME, 'size', 566, 18, 566, 22),
woosh.Token(woosh.OP, ']', 566, 22, 566, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 566, 23, 567, 0),
woosh.Token(woosh.COMMENT, '# class _Stream', 567, 0, 567, 15),
woosh.Token(woosh.DEDENT, '', 569, 0, 569, 0),
woosh.Token(woosh.DEDENT, '', 569, 0, 569, 0),
woosh.Token(woosh.NAME, 'class', 569, 0, 569, 5),
woosh.Token(woosh.NAME, '_StreamProxy', 569, 6, 569, 18),
woosh.Token(woosh.OP, '(', 569, 18, 569, 19),
woosh.Token(woosh.NAME, 'object', 569, 19, 569, 25),
woosh.Token(woosh.OP, ')', 569, 25, 569, 26),
woosh.Token(woosh.OP, ':', 569, 26, 569, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 569, 27, 570, 0),
woosh.Token(woosh.INDENT, ' ', 570, 0, 570, 4),
woosh.Token(woosh.STRING, '"""Small proxy class that enables transparent compression\r\n detection for the Stream interface (mode \'r|*\').\r\n """', 570, 4, 572, 7),
woosh.Token(woosh.NEWLINE, '\r\n', 572, 7, 573, 0),
woosh.Token(woosh.NAME, 'def', 574, 4, 574, 7),
woosh.Token(woosh.NAME, '__init__', 574, 8, 574, 16),
woosh.Token(woosh.OP, '(', 574, 16, 574, 17),
woosh.Token(woosh.NAME, 'self', 574, 17, 574, 21),
woosh.Token(woosh.OP, ',', 574, 21, 574, 22),
woosh.Token(woosh.NAME, 'fileobj', 574, 23, 574, 30),
woosh.Token(woosh.OP, ')', 574, 30, 574, 31),
woosh.Token(woosh.OP, ':', 574, 31, 574, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 574, 32, 575, 0),
woosh.Token(woosh.INDENT, ' ', 575, 0, 575, 8),
woosh.Token(woosh.NAME, 'self', 575, 8, 575, 12),
woosh.Token(woosh.OP, '.', 575, 12, 575, 13),
woosh.Token(woosh.NAME, 'fileobj', 575, 13, 575, 20),
woosh.Token(woosh.OP, '=', 575, 21, 575, 22),
woosh.Token(woosh.NAME, 'fileobj', 575, 23, 575, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 575, 30, 576, 0),
woosh.Token(woosh.NAME, 'self', 576, 8, 576, 12),
woosh.Token(woosh.OP, '.', 576, 12, 576, 13),
woosh.Token(woosh.NAME, 'buf', 576, 13, 576, 16),
woosh.Token(woosh.OP, '=', 576, 17, 576, 18),
woosh.Token(woosh.NAME, 'self', 576, 19, 576, 23),
woosh.Token(woosh.OP, '.', 576, 23, 576, 24),
woosh.Token(woosh.NAME, 'fileobj', 576, 24, 576, 31),
woosh.Token(woosh.OP, '.', 576, 31, 576, 32),
woosh.Token(woosh.NAME, 'read', 576, 32, 576, 36),
woosh.Token(woosh.OP, '(', 576, 36, 576, 37),
woosh.Token(woosh.NAME, 'BLOCKSIZE', 576, 37, 576, 46),
woosh.Token(woosh.OP, ')', 576, 46, 576, 47),
woosh.Token(woosh.NEWLINE, '\r\n', 576, 47, 577, 0),
woosh.Token(woosh.DEDENT, ' ', 578, 0, 578, 4),
woosh.Token(woosh.NAME, 'def', 578, 4, 578, 7),
woosh.Token(woosh.NAME, 'read', 578, 8, 578, 12),
woosh.Token(woosh.OP, '(', 578, 12, 578, 13),
woosh.Token(woosh.NAME, 'self', 578, 13, 578, 17),
woosh.Token(woosh.OP, ',', 578, 17, 578, 18),
woosh.Token(woosh.NAME, 'size', 578, 19, 578, 23),
woosh.Token(woosh.OP, ')', 578, 23, 578, 24),
woosh.Token(woosh.OP, ':', 578, 24, 578, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 578, 25, 579, 0),
woosh.Token(woosh.INDENT, ' ', 579, 0, 579, 8),
woosh.Token(woosh.NAME, 'self', 579, 8, 579, 12),
woosh.Token(woosh.OP, '.', 579, 12, 579, 13),
woosh.Token(woosh.NAME, 'read', 579, 13, 579, 17),
woosh.Token(woosh.OP, '=', 579, 18, 579, 19),
woosh.Token(woosh.NAME, 'self', 579, 20, 579, 24),
woosh.Token(woosh.OP, '.', 579, 24, 579, 25),
woosh.Token(woosh.NAME, 'fileobj', 579, 25, 579, 32),
woosh.Token(woosh.OP, '.', 579, 32, 579, 33),
woosh.Token(woosh.NAME, 'read', 579, 33, 579, 37),
woosh.Token(woosh.NEWLINE, '\r\n', 579, 37, 580, 0),
woosh.Token(woosh.NAME, 'return', 580, 8, 580, 14),
woosh.Token(woosh.NAME, 'self', 580, 15, 580, 19),
woosh.Token(woosh.OP, '.', 580, 19, 580, 20),
woosh.Token(woosh.NAME, 'buf', 580, 20, 580, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 580, 23, 581, 0),
woosh.Token(woosh.DEDENT, ' ', 582, 0, 582, 4),
woosh.Token(woosh.NAME, 'def', 582, 4, 582, 7),
woosh.Token(woosh.NAME, 'getcomptype', 582, 8, 582, 19),
woosh.Token(woosh.OP, '(', 582, 19, 582, 20),
woosh.Token(woosh.NAME, 'self', 582, 20, 582, 24),
woosh.Token(woosh.OP, ')', 582, 24, 582, 25),
woosh.Token(woosh.OP, ':', 582, 25, 582, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 582, 26, 583, 0),
woosh.Token(woosh.INDENT, ' ', 583, 0, 583, 8),
woosh.Token(woosh.NAME, 'if', 583, 8, 583, 10),
woosh.Token(woosh.NAME, 'self', 583, 11, 583, 15),
woosh.Token(woosh.OP, '.', 583, 15, 583, 16),
woosh.Token(woosh.NAME, 'buf', 583, 16, 583, 19),
woosh.Token(woosh.OP, '.', 583, 19, 583, 20),
woosh.Token(woosh.NAME, 'startswith', 583, 20, 583, 30),
woosh.Token(woosh.OP, '(', 583, 30, 583, 31),
woosh.Token(woosh.STRING, 'b"\\x1f\\x8b\\x08"', 583, 31, 583, 46),
woosh.Token(woosh.OP, ')', 583, 46, 583, 47),
woosh.Token(woosh.OP, ':', 583, 47, 583, 48),
woosh.Token(woosh.NEWLINE, '\r\n', 583, 48, 584, 0),
woosh.Token(woosh.INDENT, ' ', 584, 0, 584, 12),
woosh.Token(woosh.NAME, 'return', 584, 12, 584, 18),
woosh.Token(woosh.STRING, '"gz"', 584, 19, 584, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 584, 23, 585, 0),
woosh.Token(woosh.DEDENT, ' ', 585, 0, 585, 8),
woosh.Token(woosh.NAME, 'elif', 585, 8, 585, 12),
woosh.Token(woosh.NAME, 'self', 585, 13, 585, 17),
woosh.Token(woosh.OP, '.', 585, 17, 585, 18),
woosh.Token(woosh.NAME, 'buf', 585, 18, 585, 21),
woosh.Token(woosh.OP, '[', 585, 21, 585, 22),
woosh.Token(woosh.NUMBER, '0', 585, 22, 585, 23),
woosh.Token(woosh.OP, ':', 585, 23, 585, 24),
woosh.Token(woosh.NUMBER, '3', 585, 24, 585, 25),
woosh.Token(woosh.OP, ']', 585, 25, 585, 26),
woosh.Token(woosh.OP, '==', 585, 27, 585, 29),
woosh.Token(woosh.STRING, 'b"BZh"', 585, 30, 585, 36),
woosh.Token(woosh.NAME, 'and', 585, 37, 585, 40),
woosh.Token(woosh.NAME, 'self', 585, 41, 585, 45),
woosh.Token(woosh.OP, '.', 585, 45, 585, 46),
woosh.Token(woosh.NAME, 'buf', 585, 46, 585, 49),
woosh.Token(woosh.OP, '[', 585, 49, 585, 50),
woosh.Token(woosh.NUMBER, '4', 585, 50, 585, 51),
woosh.Token(woosh.OP, ':', 585, 51, 585, 52),
woosh.Token(woosh.NUMBER, '10', 585, 52, 585, 54),
woosh.Token(woosh.OP, ']', 585, 54, 585, 55),
woosh.Token(woosh.OP, '==', 585, 56, 585, 58),
woosh.Token(woosh.STRING, 'b"1AY&SY"', 585, 59, 585, 68),
woosh.Token(woosh.OP, ':', 585, 68, 585, 69),
woosh.Token(woosh.NEWLINE, '\r\n', 585, 69, 586, 0),
woosh.Token(woosh.INDENT, ' ', 586, 0, 586, 12),
woosh.Token(woosh.NAME, 'return', 586, 12, 586, 18),
woosh.Token(woosh.STRING, '"bz2"', 586, 19, 586, 24),
woosh.Token(woosh.NEWLINE, '\r\n', 586, 24, 587, 0),
woosh.Token(woosh.DEDENT, ' ', 587, 0, 587, 8),
woosh.Token(woosh.NAME, 'elif', 587, 8, 587, 12),
woosh.Token(woosh.NAME, 'self', 587, 13, 587, 17),
woosh.Token(woosh.OP, '.', 587, 17, 587, 18),
woosh.Token(woosh.NAME, 'buf', 587, 18, 587, 21),
woosh.Token(woosh.OP, '.', 587, 21, 587, 22),
woosh.Token(woosh.NAME, 'startswith', 587, 22, 587, 32),
woosh.Token(woosh.OP, '(', 587, 32, 587, 33),
woosh.Token(woosh.OP, '(', 587, 33, 587, 34),
woosh.Token(woosh.STRING, 'b"\\x5d\\x00\\x00\\x80"', 587, 34, 587, 53),
woosh.Token(woosh.OP, ',', 587, 53, 587, 54),
woosh.Token(woosh.STRING, 'b"\\xfd7zXZ"', 587, 55, 587, 66),
woosh.Token(woosh.OP, ')', 587, 66, 587, 67),
woosh.Token(woosh.OP, ')', 587, 67, 587, 68),
woosh.Token(woosh.OP, ':', 587, 68, 587, 69),
woosh.Token(woosh.NEWLINE, '\r\n', 587, 69, 588, 0),
woosh.Token(woosh.INDENT, ' ', 588, 0, 588, 12),
woosh.Token(woosh.NAME, 'return', 588, 12, 588, 18),
woosh.Token(woosh.STRING, '"xz"', 588, 19, 588, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 588, 23, 589, 0),
woosh.Token(woosh.DEDENT, ' ', 589, 0, 589, 8),
woosh.Token(woosh.NAME, 'else', 589, 8, 589, 12),
woosh.Token(woosh.OP, ':', 589, 12, 589, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 589, 13, 590, 0),
woosh.Token(woosh.INDENT, ' ', 590, 0, 590, 12),
woosh.Token(woosh.NAME, 'return', 590, 12, 590, 18),
woosh.Token(woosh.STRING, '"tar"', 590, 19, 590, 24),
woosh.Token(woosh.NEWLINE, '\r\n', 590, 24, 591, 0),
woosh.Token(woosh.DEDENT, ' ', 592, 0, 592, 4),
woosh.Token(woosh.DEDENT, '', 592, 4, 592, 4),
woosh.Token(woosh.NAME, 'def', 592, 4, 592, 7),
woosh.Token(woosh.NAME, 'close', 592, 8, 592, 13),
woosh.Token(woosh.OP, '(', 592, 13, 592, 14),
woosh.Token(woosh.NAME, 'self', 592, 14, 592, 18),
woosh.Token(woosh.OP, ')', 592, 18, 592, 19),
woosh.Token(woosh.OP, ':', 592, 19, 592, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 592, 20, 593, 0),
woosh.Token(woosh.INDENT, ' ', 593, 0, 593, 8),
woosh.Token(woosh.NAME, 'self', 593, 8, 593, 12),
woosh.Token(woosh.OP, '.', 593, 12, 593, 13),
woosh.Token(woosh.NAME, 'fileobj', 593, 13, 593, 20),
woosh.Token(woosh.OP, '.', 593, 20, 593, 21),
woosh.Token(woosh.NAME, 'close', 593, 21, 593, 26),
woosh.Token(woosh.OP, '(', 593, 26, 593, 27),
woosh.Token(woosh.OP, ')', 593, 27, 593, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 593, 28, 594, 0),
woosh.Token(woosh.COMMENT, '# class StreamProxy', 594, 0, 594, 19),
woosh.Token(woosh.COMMENT, '#------------------------', 596, 0, 596, 25),
woosh.Token(woosh.COMMENT, '# Extraction file object', 597, 0, 597, 24),
woosh.Token(woosh.COMMENT, '#------------------------', 598, 0, 598, 25),
woosh.Token(woosh.DEDENT, '', 599, 0, 599, 0),
woosh.Token(woosh.DEDENT, '', 599, 0, 599, 0),
woosh.Token(woosh.NAME, 'class', 599, 0, 599, 5),
woosh.Token(woosh.NAME, '_FileInFile', 599, 6, 599, 17),
woosh.Token(woosh.OP, '(', 599, 17, 599, 18),
woosh.Token(woosh.NAME, 'object', 599, 18, 599, 24),
woosh.Token(woosh.OP, ')', 599, 24, 599, 25),
woosh.Token(woosh.OP, ':', 599, 25, 599, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 599, 26, 600, 0),
woosh.Token(woosh.INDENT, ' ', 600, 0, 600, 4),
woosh.Token(woosh.STRING, '"""A thin wrapper around an existing file object that\r\n provides a part of its data as an individual file\r\n object.\r\n """', 600, 4, 603, 7),
woosh.Token(woosh.NEWLINE, '\r\n', 603, 7, 604, 0),
woosh.Token(woosh.NAME, 'def', 605, 4, 605, 7),
woosh.Token(woosh.NAME, '__init__', 605, 8, 605, 16),
woosh.Token(woosh.OP, '(', 605, 16, 605, 17),
woosh.Token(woosh.NAME, 'self', 605, 17, 605, 21),
woosh.Token(woosh.OP, ',', 605, 21, 605, 22),
woosh.Token(woosh.NAME, 'fileobj', 605, 23, 605, 30),
woosh.Token(woosh.OP, ',', 605, 30, 605, 31),
woosh.Token(woosh.NAME, 'offset', 605, 32, 605, 38),
woosh.Token(woosh.OP, ',', 605, 38, 605, 39),
woosh.Token(woosh.NAME, 'size', 605, 40, 605, 44),
woosh.Token(woosh.OP, ',', 605, 44, 605, 45),
woosh.Token(woosh.NAME, 'blockinfo', 605, 46, 605, 55),
woosh.Token(woosh.OP, '=', 605, 55, 605, 56),
woosh.Token(woosh.NAME, 'None', 605, 56, 605, 60),
woosh.Token(woosh.OP, ')', 605, 60, 605, 61),
woosh.Token(woosh.OP, ':', 605, 61, 605, 62),
woosh.Token(woosh.NEWLINE, '\r\n', 605, 62, 606, 0),
woosh.Token(woosh.INDENT, ' ', 606, 0, 606, 8),
woosh.Token(woosh.NAME, 'self', 606, 8, 606, 12),
woosh.Token(woosh.OP, '.', 606, 12, 606, 13),
woosh.Token(woosh.NAME, 'fileobj', 606, 13, 606, 20),
woosh.Token(woosh.OP, '=', 606, 21, 606, 22),
woosh.Token(woosh.NAME, 'fileobj', 606, 23, 606, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 606, 30, 607, 0),
woosh.Token(woosh.NAME, 'self', 607, 8, 607, 12),
woosh.Token(woosh.OP, '.', 607, 12, 607, 13),
woosh.Token(woosh.NAME, 'offset', 607, 13, 607, 19),
woosh.Token(woosh.OP, '=', 607, 20, 607, 21),
woosh.Token(woosh.NAME, 'offset', 607, 22, 607, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 607, 28, 608, 0),
woosh.Token(woosh.NAME, 'self', 608, 8, 608, 12),
woosh.Token(woosh.OP, '.', 608, 12, 608, 13),
woosh.Token(woosh.NAME, 'size', 608, 13, 608, 17),
woosh.Token(woosh.OP, '=', 608, 18, 608, 19),
woosh.Token(woosh.NAME, 'size', 608, 20, 608, 24),
woosh.Token(woosh.NEWLINE, '\r\n', 608, 24, 609, 0),
woosh.Token(woosh.NAME, 'self', 609, 8, 609, 12),
woosh.Token(woosh.OP, '.', 609, 12, 609, 13),
woosh.Token(woosh.NAME, 'position', 609, 13, 609, 21),
woosh.Token(woosh.OP, '=', 609, 22, 609, 23),
woosh.Token(woosh.NUMBER, '0', 609, 24, 609, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 609, 25, 610, 0),
woosh.Token(woosh.NAME, 'self', 610, 8, 610, 12),
woosh.Token(woosh.OP, '.', 610, 12, 610, 13),
woosh.Token(woosh.NAME, 'name', 610, 13, 610, 17),
woosh.Token(woosh.OP, '=', 610, 18, 610, 19),
woosh.Token(woosh.NAME, 'getattr', 610, 20, 610, 27),
woosh.Token(woosh.OP, '(', 610, 27, 610, 28),
woosh.Token(woosh.NAME, 'fileobj', 610, 28, 610, 35),
woosh.Token(woosh.OP, ',', 610, 35, 610, 36),
woosh.Token(woosh.STRING, '"name"', 610, 37, 610, 43),
woosh.Token(woosh.OP, ',', 610, 43, 610, 44),
woosh.Token(woosh.NAME, 'None', 610, 45, 610, 49),
woosh.Token(woosh.OP, ')', 610, 49, 610, 50),
woosh.Token(woosh.NEWLINE, '\r\n', 610, 50, 611, 0),
woosh.Token(woosh.NAME, 'self', 611, 8, 611, 12),
woosh.Token(woosh.OP, '.', 611, 12, 611, 13),
woosh.Token(woosh.NAME, 'closed', 611, 13, 611, 19),
woosh.Token(woosh.OP, '=', 611, 20, 611, 21),
woosh.Token(woosh.NAME, 'False', 611, 22, 611, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 611, 27, 612, 0),
woosh.Token(woosh.NAME, 'if', 613, 8, 613, 10),
woosh.Token(woosh.NAME, 'blockinfo', 613, 11, 613, 20),
woosh.Token(woosh.NAME, 'is', 613, 21, 613, 23),
woosh.Token(woosh.NAME, 'None', 613, 24, 613, 28),
woosh.Token(woosh.OP, ':', 613, 28, 613, 29),
woosh.Token(woosh.NEWLINE, '\r\n', 613, 29, 614, 0),
woosh.Token(woosh.INDENT, ' ', 614, 0, 614, 12),
woosh.Token(woosh.NAME, 'blockinfo', 614, 12, 614, 21),
woosh.Token(woosh.OP, '=', 614, 22, 614, 23),
woosh.Token(woosh.OP, '[', 614, 24, 614, 25),
woosh.Token(woosh.OP, '(', 614, 25, 614, 26),
woosh.Token(woosh.NUMBER, '0', 614, 26, 614, 27),
woosh.Token(woosh.OP, ',', 614, 27, 614, 28),
woosh.Token(woosh.NAME, 'size', 614, 29, 614, 33),
woosh.Token(woosh.OP, ')', 614, 33, 614, 34),
woosh.Token(woosh.OP, ']', 614, 34, 614, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 614, 35, 615, 0),
woosh.Token(woosh.COMMENT, '# Construct a map with data and zero blocks.', 616, 8, 616, 52),
woosh.Token(woosh.DEDENT, ' ', 617, 0, 617, 8),
woosh.Token(woosh.NAME, 'self', 617, 8, 617, 12),
woosh.Token(woosh.OP, '.', 617, 12, 617, 13),
woosh.Token(woosh.NAME, 'map_index', 617, 13, 617, 22),
woosh.Token(woosh.OP, '=', 617, 23, 617, 24),
woosh.Token(woosh.NUMBER, '0', 617, 25, 617, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 617, 26, 618, 0),
woosh.Token(woosh.NAME, 'self', 618, 8, 618, 12),
woosh.Token(woosh.OP, '.', 618, 12, 618, 13),
woosh.Token(woosh.NAME, 'map', 618, 13, 618, 16),
woosh.Token(woosh.OP, '=', 618, 17, 618, 18),
woosh.Token(woosh.OP, '[', 618, 19, 618, 20),
woosh.Token(woosh.OP, ']', 618, 20, 618, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 618, 21, 619, 0),
woosh.Token(woosh.NAME, 'lastpos', 619, 8, 619, 15),
woosh.Token(woosh.OP, '=', 619, 16, 619, 17),
woosh.Token(woosh.NUMBER, '0', 619, 18, 619, 19),
woosh.Token(woosh.NEWLINE, '\r\n', 619, 19, 620, 0),
woosh.Token(woosh.NAME, 'realpos', 620, 8, 620, 15),
woosh.Token(woosh.OP, '=', 620, 16, 620, 17),
woosh.Token(woosh.NAME, 'self', 620, 18, 620, 22),
woosh.Token(woosh.OP, '.', 620, 22, 620, 23),
woosh.Token(woosh.NAME, 'offset', 620, 23, 620, 29),
woosh.Token(woosh.NEWLINE, '\r\n', 620, 29, 621, 0),
woosh.Token(woosh.NAME, 'for', 621, 8, 621, 11),
woosh.Token(woosh.NAME, 'offset', 621, 12, 621, 18),
woosh.Token(woosh.OP, ',', 621, 18, 621, 19),
woosh.Token(woosh.NAME, 'size', 621, 20, 621, 24),
woosh.Token(woosh.NAME, 'in', 621, 25, 621, 27),
woosh.Token(woosh.NAME, 'blockinfo', 621, 28, 621, 37),
woosh.Token(woosh.OP, ':', 621, 37, 621, 38),
woosh.Token(woosh.NEWLINE, '\r\n', 621, 38, 622, 0),
woosh.Token(woosh.INDENT, ' ', 622, 0, 622, 12),
woosh.Token(woosh.NAME, 'if', 622, 12, 622, 14),
woosh.Token(woosh.NAME, 'offset', 622, 15, 622, 21),
woosh.Token(woosh.OP, '>', 622, 22, 622, 23),
woosh.Token(woosh.NAME, 'lastpos', 622, 24, 622, 31),
woosh.Token(woosh.OP, ':', 622, 31, 622, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 622, 32, 623, 0),
woosh.Token(woosh.INDENT, ' ', 623, 0, 623, 16),
woosh.Token(woosh.NAME, 'self', 623, 16, 623, 20),
woosh.Token(woosh.OP, '.', 623, 20, 623, 21),
woosh.Token(woosh.NAME, 'map', 623, 21, 623, 24),
woosh.Token(woosh.OP, '.', 623, 24, 623, 25),
woosh.Token(woosh.NAME, 'append', 623, 25, 623, 31),
woosh.Token(woosh.OP, '(', 623, 31, 623, 32),
woosh.Token(woosh.OP, '(', 623, 32, 623, 33),
woosh.Token(woosh.NAME, 'False', 623, 33, 623, 38),
woosh.Token(woosh.OP, ',', 623, 38, 623, 39),
woosh.Token(woosh.NAME, 'lastpos', 623, 40, 623, 47),
woosh.Token(woosh.OP, ',', 623, 47, 623, 48),
woosh.Token(woosh.NAME, 'offset', 623, 49, 623, 55),
woosh.Token(woosh.OP, ',', 623, 55, 623, 56),
woosh.Token(woosh.NAME, 'None', 623, 57, 623, 61),
woosh.Token(woosh.OP, ')', 623, 61, 623, 62),
woosh.Token(woosh.OP, ')', 623, 62, 623, 63),
woosh.Token(woosh.NEWLINE, '\r\n', 623, 63, 624, 0),
woosh.Token(woosh.DEDENT, ' ', 624, 0, 624, 12),
woosh.Token(woosh.NAME, 'self', 624, 12, 624, 16),
woosh.Token(woosh.OP, '.', 624, 16, 624, 17),
woosh.Token(woosh.NAME, 'map', 624, 17, 624, 20),
woosh.Token(woosh.OP, '.', 624, 20, 624, 21),
woosh.Token(woosh.NAME, 'append', 624, 21, 624, 27),
woosh.Token(woosh.OP, '(', 624, 27, 624, 28),
woosh.Token(woosh.OP, '(', 624, 28, 624, 29),
woosh.Token(woosh.NAME, 'True', 624, 29, 624, 33),
woosh.Token(woosh.OP, ',', 624, 33, 624, 34),
woosh.Token(woosh.NAME, 'offset', 624, 35, 624, 41),
woosh.Token(woosh.OP, ',', 624, 41, 624, 42),
woosh.Token(woosh.NAME, 'offset', 624, 43, 624, 49),
woosh.Token(woosh.OP, '+', 624, 50, 624, 51),
woosh.Token(woosh.NAME, 'size', 624, 52, 624, 56),
woosh.Token(woosh.OP, ',', 624, 56, 624, 57),
woosh.Token(woosh.NAME, 'realpos', 624, 58, 624, 65),
woosh.Token(woosh.OP, ')', 624, 65, 624, 66),
woosh.Token(woosh.OP, ')', 624, 66, 624, 67),
woosh.Token(woosh.NEWLINE, '\r\n', 624, 67, 625, 0),
woosh.Token(woosh.NAME, 'realpos', 625, 12, 625, 19),
woosh.Token(woosh.OP, '+=', 625, 20, 625, 22),
woosh.Token(woosh.NAME, 'size', 625, 23, 625, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 625, 27, 626, 0),
woosh.Token(woosh.NAME, 'lastpos', 626, 12, 626, 19),
woosh.Token(woosh.OP, '=', 626, 20, 626, 21),
woosh.Token(woosh.NAME, 'offset', 626, 22, 626, 28),
woosh.Token(woosh.OP, '+', 626, 29, 626, 30),
woosh.Token(woosh.NAME, 'size', 626, 31, 626, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 626, 35, 627, 0),
woosh.Token(woosh.DEDENT, ' ', 627, 0, 627, 8),
woosh.Token(woosh.NAME, 'if', 627, 8, 627, 10),
woosh.Token(woosh.NAME, 'lastpos', 627, 11, 627, 18),
woosh.Token(woosh.OP, '<', 627, 19, 627, 20),
woosh.Token(woosh.NAME, 'self', 627, 21, 627, 25),
woosh.Token(woosh.OP, '.', 627, 25, 627, 26),
woosh.Token(woosh.NAME, 'size', 627, 26, 627, 30),
woosh.Token(woosh.OP, ':', 627, 30, 627, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 627, 31, 628, 0),
woosh.Token(woosh.INDENT, ' ', 628, 0, 628, 12),
woosh.Token(woosh.NAME, 'self', 628, 12, 628, 16),
woosh.Token(woosh.OP, '.', 628, 16, 628, 17),
woosh.Token(woosh.NAME, 'map', 628, 17, 628, 20),
woosh.Token(woosh.OP, '.', 628, 20, 628, 21),
woosh.Token(woosh.NAME, 'append', 628, 21, 628, 27),
woosh.Token(woosh.OP, '(', 628, 27, 628, 28),
woosh.Token(woosh.OP, '(', 628, 28, 628, 29),
woosh.Token(woosh.NAME, 'False', 628, 29, 628, 34),
woosh.Token(woosh.OP, ',', 628, 34, 628, 35),
woosh.Token(woosh.NAME, 'lastpos', 628, 36, 628, 43),
woosh.Token(woosh.OP, ',', 628, 43, 628, 44),
woosh.Token(woosh.NAME, 'self', 628, 45, 628, 49),
woosh.Token(woosh.OP, '.', 628, 49, 628, 50),
woosh.Token(woosh.NAME, 'size', 628, 50, 628, 54),
woosh.Token(woosh.OP, ',', 628, 54, 628, 55),
woosh.Token(woosh.NAME, 'None', 628, 56, 628, 60),
woosh.Token(woosh.OP, ')', 628, 60, 628, 61),
woosh.Token(woosh.OP, ')', 628, 61, 628, 62),
woosh.Token(woosh.NEWLINE, '\r\n', 628, 62, 629, 0),
woosh.Token(woosh.DEDENT, ' ', 630, 0, 630, 4),
woosh.Token(woosh.DEDENT, '', 630, 4, 630, 4),
woosh.Token(woosh.NAME, 'def', 630, 4, 630, 7),
woosh.Token(woosh.NAME, 'flush', 630, 8, 630, 13),
woosh.Token(woosh.OP, '(', 630, 13, 630, 14),
woosh.Token(woosh.NAME, 'self', 630, 14, 630, 18),
woosh.Token(woosh.OP, ')', 630, 18, 630, 19),
woosh.Token(woosh.OP, ':', 630, 19, 630, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 630, 20, 631, 0),
woosh.Token(woosh.INDENT, ' ', 631, 0, 631, 8),
woosh.Token(woosh.NAME, 'pass', 631, 8, 631, 12),
woosh.Token(woosh.NEWLINE, '\r\n', 631, 12, 632, 0),
woosh.Token(woosh.DEDENT, ' ', 633, 0, 633, 4),
woosh.Token(woosh.NAME, 'def', 633, 4, 633, 7),
woosh.Token(woosh.NAME, 'readable', 633, 8, 633, 16),
woosh.Token(woosh.OP, '(', 633, 16, 633, 17),
woosh.Token(woosh.NAME, 'self', 633, 17, 633, 21),
woosh.Token(woosh.OP, ')', 633, 21, 633, 22),
woosh.Token(woosh.OP, ':', 633, 22, 633, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 633, 23, 634, 0),
woosh.Token(woosh.INDENT, ' ', 634, 0, 634, 8),
woosh.Token(woosh.NAME, 'return', 634, 8, 634, 14),
woosh.Token(woosh.NAME, 'True', 634, 15, 634, 19),
woosh.Token(woosh.NEWLINE, '\r\n', 634, 19, 635, 0),
woosh.Token(woosh.DEDENT, ' ', 636, 0, 636, 4),
woosh.Token(woosh.NAME, 'def', 636, 4, 636, 7),
woosh.Token(woosh.NAME, 'writable', 636, 8, 636, 16),
woosh.Token(woosh.OP, '(', 636, 16, 636, 17),
woosh.Token(woosh.NAME, 'self', 636, 17, 636, 21),
woosh.Token(woosh.OP, ')', 636, 21, 636, 22),
woosh.Token(woosh.OP, ':', 636, 22, 636, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 636, 23, 637, 0),
woosh.Token(woosh.INDENT, ' ', 637, 0, 637, 8),
woosh.Token(woosh.NAME, 'return', 637, 8, 637, 14),
woosh.Token(woosh.NAME, 'False', 637, 15, 637, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 637, 20, 638, 0),
woosh.Token(woosh.DEDENT, ' ', 639, 0, 639, 4),
woosh.Token(woosh.NAME, 'def', 639, 4, 639, 7),
woosh.Token(woosh.NAME, 'seekable', 639, 8, 639, 16),
woosh.Token(woosh.OP, '(', 639, 16, 639, 17),
woosh.Token(woosh.NAME, 'self', 639, 17, 639, 21),
woosh.Token(woosh.OP, ')', 639, 21, 639, 22),
woosh.Token(woosh.OP, ':', 639, 22, 639, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 639, 23, 640, 0),
woosh.Token(woosh.INDENT, ' ', 640, 0, 640, 8),
woosh.Token(woosh.NAME, 'return', 640, 8, 640, 14),
woosh.Token(woosh.NAME, 'self', 640, 15, 640, 19),
woosh.Token(woosh.OP, '.', 640, 19, 640, 20),
woosh.Token(woosh.NAME, 'fileobj', 640, 20, 640, 27),
woosh.Token(woosh.OP, '.', 640, 27, 640, 28),
woosh.Token(woosh.NAME, 'seekable', 640, 28, 640, 36),
woosh.Token(woosh.OP, '(', 640, 36, 640, 37),
woosh.Token(woosh.OP, ')', 640, 37, 640, 38),
woosh.Token(woosh.NEWLINE, '\r\n', 640, 38, 641, 0),
woosh.Token(woosh.DEDENT, ' ', 642, 0, 642, 4),
woosh.Token(woosh.NAME, 'def', 642, 4, 642, 7),
woosh.Token(woosh.NAME, 'tell', 642, 8, 642, 12),
woosh.Token(woosh.OP, '(', 642, 12, 642, 13),
woosh.Token(woosh.NAME, 'self', 642, 13, 642, 17),
woosh.Token(woosh.OP, ')', 642, 17, 642, 18),
woosh.Token(woosh.OP, ':', 642, 18, 642, 19),
woosh.Token(woosh.NEWLINE, '\r\n', 642, 19, 643, 0),
woosh.Token(woosh.INDENT, ' ', 643, 0, 643, 8),
woosh.Token(woosh.STRING, '"""Return the current file position.\r\n """', 643, 8, 644, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 644, 11, 645, 0),
woosh.Token(woosh.NAME, 'return', 645, 8, 645, 14),
woosh.Token(woosh.NAME, 'self', 645, 15, 645, 19),
woosh.Token(woosh.OP, '.', 645, 19, 645, 20),
woosh.Token(woosh.NAME, 'position', 645, 20, 645, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 645, 28, 646, 0),
woosh.Token(woosh.DEDENT, ' ', 647, 0, 647, 4),
woosh.Token(woosh.NAME, 'def', 647, 4, 647, 7),
woosh.Token(woosh.NAME, 'seek', 647, 8, 647, 12),
woosh.Token(woosh.OP, '(', 647, 12, 647, 13),
woosh.Token(woosh.NAME, 'self', 647, 13, 647, 17),
woosh.Token(woosh.OP, ',', 647, 17, 647, 18),
woosh.Token(woosh.NAME, 'position', 647, 19, 647, 27),
woosh.Token(woosh.OP, ',', 647, 27, 647, 28),
woosh.Token(woosh.NAME, 'whence', 647, 29, 647, 35),
woosh.Token(woosh.OP, '=', 647, 35, 647, 36),
woosh.Token(woosh.NAME, 'io', 647, 36, 647, 38),
woosh.Token(woosh.OP, '.', 647, 38, 647, 39),
woosh.Token(woosh.NAME, 'SEEK_SET', 647, 39, 647, 47),
woosh.Token(woosh.OP, ')', 647, 47, 647, 48),
woosh.Token(woosh.OP, ':', 647, 48, 647, 49),
woosh.Token(woosh.NEWLINE, '\r\n', 647, 49, 648, 0),
woosh.Token(woosh.INDENT, ' ', 648, 0, 648, 8),
woosh.Token(woosh.STRING, '"""Seek to a position in the file.\r\n """', 648, 8, 649, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 649, 11, 650, 0),
woosh.Token(woosh.NAME, 'if', 650, 8, 650, 10),
woosh.Token(woosh.NAME, 'whence', 650, 11, 650, 17),
woosh.Token(woosh.OP, '==', 650, 18, 650, 20),
woosh.Token(woosh.NAME, 'io', 650, 21, 650, 23),
woosh.Token(woosh.OP, '.', 650, 23, 650, 24),
woosh.Token(woosh.NAME, 'SEEK_SET', 650, 24, 650, 32),
woosh.Token(woosh.OP, ':', 650, 32, 650, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 650, 33, 651, 0),
woosh.Token(woosh.INDENT, ' ', 651, 0, 651, 12),
woosh.Token(woosh.NAME, 'self', 651, 12, 651, 16),
woosh.Token(woosh.OP, '.', 651, 16, 651, 17),
woosh.Token(woosh.NAME, 'position', 651, 17, 651, 25),
woosh.Token(woosh.OP, '=', 651, 26, 651, 27),
woosh.Token(woosh.NAME, 'min', 651, 28, 651, 31),
woosh.Token(woosh.OP, '(', 651, 31, 651, 32),
woosh.Token(woosh.NAME, 'max', 651, 32, 651, 35),
woosh.Token(woosh.OP, '(', 651, 35, 651, 36),
woosh.Token(woosh.NAME, 'position', 651, 36, 651, 44),
woosh.Token(woosh.OP, ',', 651, 44, 651, 45),
woosh.Token(woosh.NUMBER, '0', 651, 46, 651, 47),
woosh.Token(woosh.OP, ')', 651, 47, 651, 48),
woosh.Token(woosh.OP, ',', 651, 48, 651, 49),
woosh.Token(woosh.NAME, 'self', 651, 50, 651, 54),
woosh.Token(woosh.OP, '.', 651, 54, 651, 55),
woosh.Token(woosh.NAME, 'size', 651, 55, 651, 59),
woosh.Token(woosh.OP, ')', 651, 59, 651, 60),
woosh.Token(woosh.NEWLINE, '\r\n', 651, 60, 652, 0),
woosh.Token(woosh.DEDENT, ' ', 652, 0, 652, 8),
woosh.Token(woosh.NAME, 'elif', 652, 8, 652, 12),
woosh.Token(woosh.NAME, 'whence', 652, 13, 652, 19),
woosh.Token(woosh.OP, '==', 652, 20, 652, 22),
woosh.Token(woosh.NAME, 'io', 652, 23, 652, 25),
woosh.Token(woosh.OP, '.', 652, 25, 652, 26),
woosh.Token(woosh.NAME, 'SEEK_CUR', 652, 26, 652, 34),
woosh.Token(woosh.OP, ':', 652, 34, 652, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 652, 35, 653, 0),
woosh.Token(woosh.INDENT, ' ', 653, 0, 653, 12),
woosh.Token(woosh.NAME, 'if', 653, 12, 653, 14),
woosh.Token(woosh.NAME, 'position', 653, 15, 653, 23),
woosh.Token(woosh.OP, '<', 653, 24, 653, 25),
woosh.Token(woosh.NUMBER, '0', 653, 26, 653, 27),
woosh.Token(woosh.OP, ':', 653, 27, 653, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 653, 28, 654, 0),
woosh.Token(woosh.INDENT, ' ', 654, 0, 654, 16),
woosh.Token(woosh.NAME, 'self', 654, 16, 654, 20),
woosh.Token(woosh.OP, '.', 654, 20, 654, 21),
woosh.Token(woosh.NAME, 'position', 654, 21, 654, 29),
woosh.Token(woosh.OP, '=', 654, 30, 654, 31),
woosh.Token(woosh.NAME, 'max', 654, 32, 654, 35),
woosh.Token(woosh.OP, '(', 654, 35, 654, 36),
woosh.Token(woosh.NAME, 'self', 654, 36, 654, 40),
woosh.Token(woosh.OP, '.', 654, 40, 654, 41),
woosh.Token(woosh.NAME, 'position', 654, 41, 654, 49),
woosh.Token(woosh.OP, '+', 654, 50, 654, 51),
woosh.Token(woosh.NAME, 'position', 654, 52, 654, 60),
woosh.Token(woosh.OP, ',', 654, 60, 654, 61),
woosh.Token(woosh.NUMBER, '0', 654, 62, 654, 63),
woosh.Token(woosh.OP, ')', 654, 63, 654, 64),
woosh.Token(woosh.NEWLINE, '\r\n', 654, 64, 655, 0),
woosh.Token(woosh.DEDENT, ' ', 655, 0, 655, 12),
woosh.Token(woosh.NAME, 'else', 655, 12, 655, 16),
woosh.Token(woosh.OP, ':', 655, 16, 655, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 655, 17, 656, 0),
woosh.Token(woosh.INDENT, ' ', 656, 0, 656, 16),
woosh.Token(woosh.NAME, 'self', 656, 16, 656, 20),
woosh.Token(woosh.OP, '.', 656, 20, 656, 21),
woosh.Token(woosh.NAME, 'position', 656, 21, 656, 29),
woosh.Token(woosh.OP, '=', 656, 30, 656, 31),
woosh.Token(woosh.NAME, 'min', 656, 32, 656, 35),
woosh.Token(woosh.OP, '(', 656, 35, 656, 36),
woosh.Token(woosh.NAME, 'self', 656, 36, 656, 40),
woosh.Token(woosh.OP, '.', 656, 40, 656, 41),
woosh.Token(woosh.NAME, 'position', 656, 41, 656, 49),
woosh.Token(woosh.OP, '+', 656, 50, 656, 51),
woosh.Token(woosh.NAME, 'position', 656, 52, 656, 60),
woosh.Token(woosh.OP, ',', 656, 60, 656, 61),
woosh.Token(woosh.NAME, 'self', 656, 62, 656, 66),
woosh.Token(woosh.OP, '.', 656, 66, 656, 67),
woosh.Token(woosh.NAME, 'size', 656, 67, 656, 71),
woosh.Token(woosh.OP, ')', 656, 71, 656, 72),
woosh.Token(woosh.NEWLINE, '\r\n', 656, 72, 657, 0),
woosh.Token(woosh.DEDENT, ' ', 657, 0, 657, 8),
woosh.Token(woosh.DEDENT, '', 657, 8, 657, 8),
woosh.Token(woosh.NAME, 'elif', 657, 8, 657, 12),
woosh.Token(woosh.NAME, 'whence', 657, 13, 657, 19),
woosh.Token(woosh.OP, '==', 657, 20, 657, 22),
woosh.Token(woosh.NAME, 'io', 657, 23, 657, 25),
woosh.Token(woosh.OP, '.', 657, 25, 657, 26),
woosh.Token(woosh.NAME, 'SEEK_END', 657, 26, 657, 34),
woosh.Token(woosh.OP, ':', 657, 34, 657, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 657, 35, 658, 0),
woosh.Token(woosh.INDENT, ' ', 658, 0, 658, 12),
woosh.Token(woosh.NAME, 'self', 658, 12, 658, 16),
woosh.Token(woosh.OP, '.', 658, 16, 658, 17),
woosh.Token(woosh.NAME, 'position', 658, 17, 658, 25),
woosh.Token(woosh.OP, '=', 658, 26, 658, 27),
woosh.Token(woosh.NAME, 'max', 658, 28, 658, 31),
woosh.Token(woosh.OP, '(', 658, 31, 658, 32),
woosh.Token(woosh.NAME, 'min', 658, 32, 658, 35),
woosh.Token(woosh.OP, '(', 658, 35, 658, 36),
woosh.Token(woosh.NAME, 'self', 658, 36, 658, 40),
woosh.Token(woosh.OP, '.', 658, 40, 658, 41),
woosh.Token(woosh.NAME, 'size', 658, 41, 658, 45),
woosh.Token(woosh.OP, '+', 658, 46, 658, 47),
woosh.Token(woosh.NAME, 'position', 658, 48, 658, 56),
woosh.Token(woosh.OP, ',', 658, 56, 658, 57),
woosh.Token(woosh.NAME, 'self', 658, 58, 658, 62),
woosh.Token(woosh.OP, '.', 658, 62, 658, 63),
woosh.Token(woosh.NAME, 'size', 658, 63, 658, 67),
woosh.Token(woosh.OP, ')', 658, 67, 658, 68),
woosh.Token(woosh.OP, ',', 658, 68, 658, 69),
woosh.Token(woosh.NUMBER, '0', 658, 70, 658, 71),
woosh.Token(woosh.OP, ')', 658, 71, 658, 72),
woosh.Token(woosh.NEWLINE, '\r\n', 658, 72, 659, 0),
woosh.Token(woosh.DEDENT, ' ', 659, 0, 659, 8),
woosh.Token(woosh.NAME, 'else', 659, 8, 659, 12),
woosh.Token(woosh.OP, ':', 659, 12, 659, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 659, 13, 660, 0),
woosh.Token(woosh.INDENT, ' ', 660, 0, 660, 12),
woosh.Token(woosh.NAME, 'raise', 660, 12, 660, 17),
woosh.Token(woosh.NAME, 'ValueError', 660, 18, 660, 28),
woosh.Token(woosh.OP, '(', 660, 28, 660, 29),
woosh.Token(woosh.STRING, '"Invalid argument"', 660, 29, 660, 47),
woosh.Token(woosh.OP, ')', 660, 47, 660, 48),
woosh.Token(woosh.NEWLINE, '\r\n', 660, 48, 661, 0),
woosh.Token(woosh.DEDENT, ' ', 661, 0, 661, 8),
woosh.Token(woosh.NAME, 'return', 661, 8, 661, 14),
woosh.Token(woosh.NAME, 'self', 661, 15, 661, 19),
woosh.Token(woosh.OP, '.', 661, 19, 661, 20),
woosh.Token(woosh.NAME, 'position', 661, 20, 661, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 661, 28, 662, 0),
woosh.Token(woosh.DEDENT, ' ', 663, 0, 663, 4),
woosh.Token(woosh.NAME, 'def', 663, 4, 663, 7),
woosh.Token(woosh.NAME, 'read', 663, 8, 663, 12),
woosh.Token(woosh.OP, '(', 663, 12, 663, 13),
woosh.Token(woosh.NAME, 'self', 663, 13, 663, 17),
woosh.Token(woosh.OP, ',', 663, 17, 663, 18),
woosh.Token(woosh.NAME, 'size', 663, 19, 663, 23),
woosh.Token(woosh.OP, '=', 663, 23, 663, 24),
woosh.Token(woosh.NAME, 'None', 663, 24, 663, 28),
woosh.Token(woosh.OP, ')', 663, 28, 663, 29),
woosh.Token(woosh.OP, ':', 663, 29, 663, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 663, 30, 664, 0),
woosh.Token(woosh.INDENT, ' ', 664, 0, 664, 8),
woosh.Token(woosh.STRING, '"""Read data from the file.\r\n """', 664, 8, 665, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 665, 11, 666, 0),
woosh.Token(woosh.NAME, 'if', 666, 8, 666, 10),
woosh.Token(woosh.NAME, 'size', 666, 11, 666, 15),
woosh.Token(woosh.NAME, 'is', 666, 16, 666, 18),
woosh.Token(woosh.NAME, 'None', 666, 19, 666, 23),
woosh.Token(woosh.OP, ':', 666, 23, 666, 24),
woosh.Token(woosh.NEWLINE, '\r\n', 666, 24, 667, 0),
woosh.Token(woosh.INDENT, ' ', 667, 0, 667, 12),
woosh.Token(woosh.NAME, 'size', 667, 12, 667, 16),
woosh.Token(woosh.OP, '=', 667, 17, 667, 18),
woosh.Token(woosh.NAME, 'self', 667, 19, 667, 23),
woosh.Token(woosh.OP, '.', 667, 23, 667, 24),
woosh.Token(woosh.NAME, 'size', 667, 24, 667, 28),
woosh.Token(woosh.OP, '-', 667, 29, 667, 30),
woosh.Token(woosh.NAME, 'self', 667, 31, 667, 35),
woosh.Token(woosh.OP, '.', 667, 35, 667, 36),
woosh.Token(woosh.NAME, 'position', 667, 36, 667, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 667, 44, 668, 0),
woosh.Token(woosh.DEDENT, ' ', 668, 0, 668, 8),
woosh.Token(woosh.NAME, 'else', 668, 8, 668, 12),
woosh.Token(woosh.OP, ':', 668, 12, 668, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 668, 13, 669, 0),
woosh.Token(woosh.INDENT, ' ', 669, 0, 669, 12),
woosh.Token(woosh.NAME, 'size', 669, 12, 669, 16),
woosh.Token(woosh.OP, '=', 669, 17, 669, 18),
woosh.Token(woosh.NAME, 'min', 669, 19, 669, 22),
woosh.Token(woosh.OP, '(', 669, 22, 669, 23),
woosh.Token(woosh.NAME, 'size', 669, 23, 669, 27),
woosh.Token(woosh.OP, ',', 669, 27, 669, 28),
woosh.Token(woosh.NAME, 'self', 669, 29, 669, 33),
woosh.Token(woosh.OP, '.', 669, 33, 669, 34),
woosh.Token(woosh.NAME, 'size', 669, 34, 669, 38),
woosh.Token(woosh.OP, '-', 669, 39, 669, 40),
woosh.Token(woosh.NAME, 'self', 669, 41, 669, 45),
woosh.Token(woosh.OP, '.', 669, 45, 669, 46),
woosh.Token(woosh.NAME, 'position', 669, 46, 669, 54),
woosh.Token(woosh.OP, ')', 669, 54, 669, 55),
woosh.Token(woosh.NEWLINE, '\r\n', 669, 55, 670, 0),
woosh.Token(woosh.DEDENT, ' ', 671, 0, 671, 8),
woosh.Token(woosh.NAME, 'buf', 671, 8, 671, 11),
woosh.Token(woosh.OP, '=', 671, 12, 671, 13),
woosh.Token(woosh.STRING, 'b""', 671, 14, 671, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 671, 17, 672, 0),
woosh.Token(woosh.NAME, 'while', 672, 8, 672, 13),
woosh.Token(woosh.NAME, 'size', 672, 14, 672, 18),
woosh.Token(woosh.OP, '>', 672, 19, 672, 20),
woosh.Token(woosh.NUMBER, '0', 672, 21, 672, 22),
woosh.Token(woosh.OP, ':', 672, 22, 672, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 672, 23, 673, 0),
woosh.Token(woosh.INDENT, ' ', 673, 0, 673, 12),
woosh.Token(woosh.NAME, 'while', 673, 12, 673, 17),
woosh.Token(woosh.NAME, 'True', 673, 18, 673, 22),
woosh.Token(woosh.OP, ':', 673, 22, 673, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 673, 23, 674, 0),
woosh.Token(woosh.INDENT, ' ', 674, 0, 674, 16),
woosh.Token(woosh.NAME, 'data', 674, 16, 674, 20),
woosh.Token(woosh.OP, ',', 674, 20, 674, 21),
woosh.Token(woosh.NAME, 'start', 674, 22, 674, 27),
woosh.Token(woosh.OP, ',', 674, 27, 674, 28),
woosh.Token(woosh.NAME, 'stop', 674, 29, 674, 33),
woosh.Token(woosh.OP, ',', 674, 33, 674, 34),
woosh.Token(woosh.NAME, 'offset', 674, 35, 674, 41),
woosh.Token(woosh.OP, '=', 674, 42, 674, 43),
woosh.Token(woosh.NAME, 'self', 674, 44, 674, 48),
woosh.Token(woosh.OP, '.', 674, 48, 674, 49),
woosh.Token(woosh.NAME, 'map', 674, 49, 674, 52),
woosh.Token(woosh.OP, '[', 674, 52, 674, 53),
woosh.Token(woosh.NAME, 'self', 674, 53, 674, 57),
woosh.Token(woosh.OP, '.', 674, 57, 674, 58),
woosh.Token(woosh.NAME, 'map_index', 674, 58, 674, 67),
woosh.Token(woosh.OP, ']', 674, 67, 674, 68),
woosh.Token(woosh.NEWLINE, '\r\n', 674, 68, 675, 0),
woosh.Token(woosh.NAME, 'if', 675, 16, 675, 18),
woosh.Token(woosh.NAME, 'start', 675, 19, 675, 24),
woosh.Token(woosh.OP, '<=', 675, 25, 675, 27),
woosh.Token(woosh.NAME, 'self', 675, 28, 675, 32),
woosh.Token(woosh.OP, '.', 675, 32, 675, 33),
woosh.Token(woosh.NAME, 'position', 675, 33, 675, 41),
woosh.Token(woosh.OP, '<', 675, 42, 675, 43),
woosh.Token(woosh.NAME, 'stop', 675, 44, 675, 48),
woosh.Token(woosh.OP, ':', 675, 48, 675, 49),
woosh.Token(woosh.NEWLINE, '\r\n', 675, 49, 676, 0),
woosh.Token(woosh.INDENT, ' ', 676, 0, 676, 20),
woosh.Token(woosh.NAME, 'break', 676, 20, 676, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 676, 25, 677, 0),
woosh.Token(woosh.DEDENT, ' ', 677, 0, 677, 16),
woosh.Token(woosh.NAME, 'else', 677, 16, 677, 20),
woosh.Token(woosh.OP, ':', 677, 20, 677, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 677, 21, 678, 0),
woosh.Token(woosh.INDENT, ' ', 678, 0, 678, 20),
woosh.Token(woosh.NAME, 'self', 678, 20, 678, 24),
woosh.Token(woosh.OP, '.', 678, 24, 678, 25),
woosh.Token(woosh.NAME, 'map_index', 678, 25, 678, 34),
woosh.Token(woosh.OP, '+=', 678, 35, 678, 37),
woosh.Token(woosh.NUMBER, '1', 678, 38, 678, 39),
woosh.Token(woosh.NEWLINE, '\r\n', 678, 39, 679, 0),
woosh.Token(woosh.NAME, 'if', 679, 20, 679, 22),
woosh.Token(woosh.NAME, 'self', 679, 23, 679, 27),
woosh.Token(woosh.OP, '.', 679, 27, 679, 28),
woosh.Token(woosh.NAME, 'map_index', 679, 28, 679, 37),
woosh.Token(woosh.OP, '==', 679, 38, 679, 40),
woosh.Token(woosh.NAME, 'len', 679, 41, 679, 44),
woosh.Token(woosh.OP, '(', 679, 44, 679, 45),
woosh.Token(woosh.NAME, 'self', 679, 45, 679, 49),
woosh.Token(woosh.OP, '.', 679, 49, 679, 50),
woosh.Token(woosh.NAME, 'map', 679, 50, 679, 53),
woosh.Token(woosh.OP, ')', 679, 53, 679, 54),
woosh.Token(woosh.OP, ':', 679, 54, 679, 55),
woosh.Token(woosh.NEWLINE, '\r\n', 679, 55, 680, 0),
woosh.Token(woosh.INDENT, ' ', 680, 0, 680, 24),
woosh.Token(woosh.NAME, 'self', 680, 24, 680, 28),
woosh.Token(woosh.OP, '.', 680, 28, 680, 29),
woosh.Token(woosh.NAME, 'map_index', 680, 29, 680, 38),
woosh.Token(woosh.OP, '=', 680, 39, 680, 40),
woosh.Token(woosh.NUMBER, '0', 680, 41, 680, 42),
woosh.Token(woosh.NEWLINE, '\r\n', 680, 42, 681, 0),
woosh.Token(woosh.DEDENT, ' ', 681, 0, 681, 12),
woosh.Token(woosh.DEDENT, '', 681, 12, 681, 12),
woosh.Token(woosh.DEDENT, '', 681, 12, 681, 12),
woosh.Token(woosh.NAME, 'length', 681, 12, 681, 18),
woosh.Token(woosh.OP, '=', 681, 19, 681, 20),
woosh.Token(woosh.NAME, 'min', 681, 21, 681, 24),
woosh.Token(woosh.OP, '(', 681, 24, 681, 25),
woosh.Token(woosh.NAME, 'size', 681, 25, 681, 29),
woosh.Token(woosh.OP, ',', 681, 29, 681, 30),
woosh.Token(woosh.NAME, 'stop', 681, 31, 681, 35),
woosh.Token(woosh.OP, '-', 681, 36, 681, 37),
woosh.Token(woosh.NAME, 'self', 681, 38, 681, 42),
woosh.Token(woosh.OP, '.', 681, 42, 681, 43),
woosh.Token(woosh.NAME, 'position', 681, 43, 681, 51),
woosh.Token(woosh.OP, ')', 681, 51, 681, 52),
woosh.Token(woosh.NEWLINE, '\r\n', 681, 52, 682, 0),
woosh.Token(woosh.NAME, 'if', 682, 12, 682, 14),
woosh.Token(woosh.NAME, 'data', 682, 15, 682, 19),
woosh.Token(woosh.OP, ':', 682, 19, 682, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 682, 20, 683, 0),
woosh.Token(woosh.INDENT, ' ', 683, 0, 683, 16),
woosh.Token(woosh.NAME, 'self', 683, 16, 683, 20),
woosh.Token(woosh.OP, '.', 683, 20, 683, 21),
woosh.Token(woosh.NAME, 'fileobj', 683, 21, 683, 28),
woosh.Token(woosh.OP, '.', 683, 28, 683, 29),
woosh.Token(woosh.NAME, 'seek', 683, 29, 683, 33),
woosh.Token(woosh.OP, '(', 683, 33, 683, 34),
woosh.Token(woosh.NAME, 'offset', 683, 34, 683, 40),
woosh.Token(woosh.OP, '+', 683, 41, 683, 42),
woosh.Token(woosh.OP, '(', 683, 43, 683, 44),
woosh.Token(woosh.NAME, 'self', 683, 44, 683, 48),
woosh.Token(woosh.OP, '.', 683, 48, 683, 49),
woosh.Token(woosh.NAME, 'position', 683, 49, 683, 57),
woosh.Token(woosh.OP, '-', 683, 58, 683, 59),
woosh.Token(woosh.NAME, 'start', 683, 60, 683, 65),
woosh.Token(woosh.OP, ')', 683, 65, 683, 66),
woosh.Token(woosh.OP, ')', 683, 66, 683, 67),
woosh.Token(woosh.NEWLINE, '\r\n', 683, 67, 684, 0),
woosh.Token(woosh.NAME, 'b', 684, 16, 684, 17),
woosh.Token(woosh.OP, '=', 684, 18, 684, 19),
woosh.Token(woosh.NAME, 'self', 684, 20, 684, 24),
woosh.Token(woosh.OP, '.', 684, 24, 684, 25),
woosh.Token(woosh.NAME, 'fileobj', 684, 25, 684, 32),
woosh.Token(woosh.OP, '.', 684, 32, 684, 33),
woosh.Token(woosh.NAME, 'read', 684, 33, 684, 37),
woosh.Token(woosh.OP, '(', 684, 37, 684, 38),
woosh.Token(woosh.NAME, 'length', 684, 38, 684, 44),
woosh.Token(woosh.OP, ')', 684, 44, 684, 45),
woosh.Token(woosh.NEWLINE, '\r\n', 684, 45, 685, 0),
woosh.Token(woosh.NAME, 'if', 685, 16, 685, 18),
woosh.Token(woosh.NAME, 'len', 685, 19, 685, 22),
woosh.Token(woosh.OP, '(', 685, 22, 685, 23),
woosh.Token(woosh.NAME, 'b', 685, 23, 685, 24),
woosh.Token(woosh.OP, ')', 685, 24, 685, 25),
woosh.Token(woosh.OP, '!=', 685, 26, 685, 28),
woosh.Token(woosh.NAME, 'length', 685, 29, 685, 35),
woosh.Token(woosh.OP, ':', 685, 35, 685, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 685, 36, 686, 0),
woosh.Token(woosh.INDENT, ' ', 686, 0, 686, 20),
woosh.Token(woosh.NAME, 'raise', 686, 20, 686, 25),
woosh.Token(woosh.NAME, 'ReadError', 686, 26, 686, 35),
woosh.Token(woosh.OP, '(', 686, 35, 686, 36),
woosh.Token(woosh.STRING, '"unexpected end of data"', 686, 36, 686, 60),
woosh.Token(woosh.OP, ')', 686, 60, 686, 61),
woosh.Token(woosh.NEWLINE, '\r\n', 686, 61, 687, 0),
woosh.Token(woosh.DEDENT, ' ', 687, 0, 687, 16),
woosh.Token(woosh.NAME, 'buf', 687, 16, 687, 19),
woosh.Token(woosh.OP, '+=', 687, 20, 687, 22),
woosh.Token(woosh.NAME, 'b', 687, 23, 687, 24),
woosh.Token(woosh.NEWLINE, '\r\n', 687, 24, 688, 0),
woosh.Token(woosh.DEDENT, ' ', 688, 0, 688, 12),
woosh.Token(woosh.NAME, 'else', 688, 12, 688, 16),
woosh.Token(woosh.OP, ':', 688, 16, 688, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 688, 17, 689, 0),
woosh.Token(woosh.INDENT, ' ', 689, 0, 689, 16),
woosh.Token(woosh.NAME, 'buf', 689, 16, 689, 19),
woosh.Token(woosh.OP, '+=', 689, 20, 689, 22),
woosh.Token(woosh.NAME, 'NUL', 689, 23, 689, 26),
woosh.Token(woosh.OP, '*', 689, 27, 689, 28),
woosh.Token(woosh.NAME, 'length', 689, 29, 689, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 689, 35, 690, 0),
woosh.Token(woosh.DEDENT, ' ', 690, 0, 690, 12),
woosh.Token(woosh.NAME, 'size', 690, 12, 690, 16),
woosh.Token(woosh.OP, '-=', 690, 17, 690, 19),
woosh.Token(woosh.NAME, 'length', 690, 20, 690, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 690, 26, 691, 0),
woosh.Token(woosh.NAME, 'self', 691, 12, 691, 16),
woosh.Token(woosh.OP, '.', 691, 16, 691, 17),
woosh.Token(woosh.NAME, 'position', 691, 17, 691, 25),
woosh.Token(woosh.OP, '+=', 691, 26, 691, 28),
woosh.Token(woosh.NAME, 'length', 691, 29, 691, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 691, 35, 692, 0),
woosh.Token(woosh.DEDENT, ' ', 692, 0, 692, 8),
woosh.Token(woosh.NAME, 'return', 692, 8, 692, 14),
woosh.Token(woosh.NAME, 'buf', 692, 15, 692, 18),
woosh.Token(woosh.NEWLINE, '\r\n', 692, 18, 693, 0),
woosh.Token(woosh.DEDENT, ' ', 694, 0, 694, 4),
woosh.Token(woosh.NAME, 'def', 694, 4, 694, 7),
woosh.Token(woosh.NAME, 'readinto', 694, 8, 694, 16),
woosh.Token(woosh.OP, '(', 694, 16, 694, 17),
woosh.Token(woosh.NAME, 'self', 694, 17, 694, 21),
woosh.Token(woosh.OP, ',', 694, 21, 694, 22),
woosh.Token(woosh.NAME, 'b', 694, 23, 694, 24),
woosh.Token(woosh.OP, ')', 694, 24, 694, 25),
woosh.Token(woosh.OP, ':', 694, 25, 694, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 694, 26, 695, 0),
woosh.Token(woosh.INDENT, ' ', 695, 0, 695, 8),
woosh.Token(woosh.NAME, 'buf', 695, 8, 695, 11),
woosh.Token(woosh.OP, '=', 695, 12, 695, 13),
woosh.Token(woosh.NAME, 'self', 695, 14, 695, 18),
woosh.Token(woosh.OP, '.', 695, 18, 695, 19),
woosh.Token(woosh.NAME, 'read', 695, 19, 695, 23),
woosh.Token(woosh.OP, '(', 695, 23, 695, 24),
woosh.Token(woosh.NAME, 'len', 695, 24, 695, 27),
woosh.Token(woosh.OP, '(', 695, 27, 695, 28),
woosh.Token(woosh.NAME, 'b', 695, 28, 695, 29),
woosh.Token(woosh.OP, ')', 695, 29, 695, 30),
woosh.Token(woosh.OP, ')', 695, 30, 695, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 695, 31, 696, 0),
woosh.Token(woosh.NAME, 'b', 696, 8, 696, 9),
woosh.Token(woosh.OP, '[', 696, 9, 696, 10),
woosh.Token(woosh.OP, ':', 696, 10, 696, 11),
woosh.Token(woosh.NAME, 'len', 696, 11, 696, 14),
woosh.Token(woosh.OP, '(', 696, 14, 696, 15),
woosh.Token(woosh.NAME, 'buf', 696, 15, 696, 18),
woosh.Token(woosh.OP, ')', 696, 18, 696, 19),
woosh.Token(woosh.OP, ']', 696, 19, 696, 20),
woosh.Token(woosh.OP, '=', 696, 21, 696, 22),
woosh.Token(woosh.NAME, 'buf', 696, 23, 696, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 696, 26, 697, 0),
woosh.Token(woosh.NAME, 'return', 697, 8, 697, 14),
woosh.Token(woosh.NAME, 'len', 697, 15, 697, 18),
woosh.Token(woosh.OP, '(', 697, 18, 697, 19),
woosh.Token(woosh.NAME, 'buf', 697, 19, 697, 22),
woosh.Token(woosh.OP, ')', 697, 22, 697, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 697, 23, 698, 0),
woosh.Token(woosh.DEDENT, ' ', 699, 0, 699, 4),
woosh.Token(woosh.NAME, 'def', 699, 4, 699, 7),
woosh.Token(woosh.NAME, 'close', 699, 8, 699, 13),
woosh.Token(woosh.OP, '(', 699, 13, 699, 14),
woosh.Token(woosh.NAME, 'self', 699, 14, 699, 18),
woosh.Token(woosh.OP, ')', 699, 18, 699, 19),
woosh.Token(woosh.OP, ':', 699, 19, 699, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 699, 20, 700, 0),
woosh.Token(woosh.INDENT, ' ', 700, 0, 700, 8),
woosh.Token(woosh.NAME, 'self', 700, 8, 700, 12),
woosh.Token(woosh.OP, '.', 700, 12, 700, 13),
woosh.Token(woosh.NAME, 'closed', 700, 13, 700, 19),
woosh.Token(woosh.OP, '=', 700, 20, 700, 21),
woosh.Token(woosh.NAME, 'True', 700, 22, 700, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 700, 26, 701, 0),
woosh.Token(woosh.COMMENT, '#class _FileInFile', 701, 0, 701, 18),
woosh.Token(woosh.DEDENT, '', 703, 0, 703, 0),
woosh.Token(woosh.DEDENT, '', 703, 0, 703, 0),
woosh.Token(woosh.NAME, 'class', 703, 0, 703, 5),
woosh.Token(woosh.NAME, 'ExFileObject', 703, 6, 703, 18),
woosh.Token(woosh.OP, '(', 703, 18, 703, 19),
woosh.Token(woosh.NAME, 'io', 703, 19, 703, 21),
woosh.Token(woosh.OP, '.', 703, 21, 703, 22),
woosh.Token(woosh.NAME, 'BufferedReader', 703, 22, 703, 36),
woosh.Token(woosh.OP, ')', 703, 36, 703, 37),
woosh.Token(woosh.OP, ':', 703, 37, 703, 38),
woosh.Token(woosh.NEWLINE, '\r\n', 703, 38, 704, 0),
woosh.Token(woosh.INDENT, ' ', 705, 0, 705, 4),
woosh.Token(woosh.NAME, 'def', 705, 4, 705, 7),
woosh.Token(woosh.NAME, '__init__', 705, 8, 705, 16),
woosh.Token(woosh.OP, '(', 705, 16, 705, 17),
woosh.Token(woosh.NAME, 'self', 705, 17, 705, 21),
woosh.Token(woosh.OP, ',', 705, 21, 705, 22),
woosh.Token(woosh.NAME, 'tarfile', 705, 23, 705, 30),
woosh.Token(woosh.OP, ',', 705, 30, 705, 31),
woosh.Token(woosh.NAME, 'tarinfo', 705, 32, 705, 39),
woosh.Token(woosh.OP, ')', 705, 39, 705, 40),
woosh.Token(woosh.OP, ':', 705, 40, 705, 41),
woosh.Token(woosh.NEWLINE, '\r\n', 705, 41, 706, 0),
woosh.Token(woosh.INDENT, ' ', 706, 0, 706, 8),
woosh.Token(woosh.NAME, 'fileobj', 706, 8, 706, 15),
woosh.Token(woosh.OP, '=', 706, 16, 706, 17),
woosh.Token(woosh.NAME, '_FileInFile', 706, 18, 706, 29),
woosh.Token(woosh.OP, '(', 706, 29, 706, 30),
woosh.Token(woosh.NAME, 'tarfile', 706, 30, 706, 37),
woosh.Token(woosh.OP, '.', 706, 37, 706, 38),
woosh.Token(woosh.NAME, 'fileobj', 706, 38, 706, 45),
woosh.Token(woosh.OP, ',', 706, 45, 706, 46),
woosh.Token(woosh.NAME, 'tarinfo', 706, 47, 706, 54),
woosh.Token(woosh.OP, '.', 706, 54, 706, 55),
woosh.Token(woosh.NAME, 'offset_data', 706, 55, 706, 66),
woosh.Token(woosh.OP, ',', 706, 66, 706, 67),
woosh.Token(woosh.NAME, 'tarinfo', 707, 16, 707, 23),
woosh.Token(woosh.OP, '.', 707, 23, 707, 24),
woosh.Token(woosh.NAME, 'size', 707, 24, 707, 28),
woosh.Token(woosh.OP, ',', 707, 28, 707, 29),
woosh.Token(woosh.NAME, 'tarinfo', 707, 30, 707, 37),
woosh.Token(woosh.OP, '.', 707, 37, 707, 38),
woosh.Token(woosh.NAME, 'sparse', 707, 38, 707, 44),
woosh.Token(woosh.OP, ')', 707, 44, 707, 45),
woosh.Token(woosh.NEWLINE, '\r\n', 707, 45, 708, 0),
woosh.Token(woosh.NAME, 'super', 708, 8, 708, 13),
woosh.Token(woosh.OP, '(', 708, 13, 708, 14),
woosh.Token(woosh.OP, ')', 708, 14, 708, 15),
woosh.Token(woosh.OP, '.', 708, 15, 708, 16),
woosh.Token(woosh.NAME, '__init__', 708, 16, 708, 24),
woosh.Token(woosh.OP, '(', 708, 24, 708, 25),
woosh.Token(woosh.NAME, 'fileobj', 708, 25, 708, 32),
woosh.Token(woosh.OP, ')', 708, 32, 708, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 708, 33, 709, 0),
woosh.Token(woosh.COMMENT, '#class ExFileObject', 709, 0, 709, 19),
woosh.Token(woosh.COMMENT, '#------------------', 711, 0, 711, 19),
woosh.Token(woosh.COMMENT, '# Exported Classes', 712, 0, 712, 18),
woosh.Token(woosh.COMMENT, '#------------------', 713, 0, 713, 19),
woosh.Token(woosh.DEDENT, '', 714, 0, 714, 0),
woosh.Token(woosh.DEDENT, '', 714, 0, 714, 0),
woosh.Token(woosh.NAME, 'class', 714, 0, 714, 5),
woosh.Token(woosh.NAME, 'TarInfo', 714, 6, 714, 13),
woosh.Token(woosh.OP, '(', 714, 13, 714, 14),
woosh.Token(woosh.NAME, 'object', 714, 14, 714, 20),
woosh.Token(woosh.OP, ')', 714, 20, 714, 21),
woosh.Token(woosh.OP, ':', 714, 21, 714, 22),
woosh.Token(woosh.NEWLINE, '\r\n', 714, 22, 715, 0),
woosh.Token(woosh.INDENT, ' ', 715, 0, 715, 4),
woosh.Token(woosh.STRING, '"""Informational class which holds the details about an\r\n archive member given by a tar header block.\r\n TarInfo objects are returned by TarFile.getmember(),\r\n TarFile.getmembers() and TarFile.gettarinfo() and are\r\n usually created internally.\r\n """', 715, 4, 720, 7),
woosh.Token(woosh.NEWLINE, '\r\n', 720, 7, 721, 0),
woosh.Token(woosh.NAME, '__slots__', 722, 4, 722, 13),
woosh.Token(woosh.OP, '=', 722, 14, 722, 15),
woosh.Token(woosh.NAME, 'dict', 722, 16, 722, 20),
woosh.Token(woosh.OP, '(', 722, 20, 722, 21),
woosh.Token(woosh.NAME, 'name', 723, 8, 723, 12),
woosh.Token(woosh.OP, '=', 723, 13, 723, 14),
woosh.Token(woosh.STRING, "'Name of the archive member.'", 723, 15, 723, 44),
woosh.Token(woosh.OP, ',', 723, 44, 723, 45),
woosh.Token(woosh.NAME, 'mode', 724, 8, 724, 12),
woosh.Token(woosh.OP, '=', 724, 13, 724, 14),
woosh.Token(woosh.STRING, "'Permission bits.'", 724, 15, 724, 33),
woosh.Token(woosh.OP, ',', 724, 33, 724, 34),
woosh.Token(woosh.NAME, 'uid', 725, 8, 725, 11),
woosh.Token(woosh.OP, '=', 725, 12, 725, 13),
woosh.Token(woosh.STRING, "'User ID of the user who originally stored this member.'", 725, 14, 725, 70),
woosh.Token(woosh.OP, ',', 725, 70, 725, 71),
woosh.Token(woosh.NAME, 'gid', 726, 8, 726, 11),
woosh.Token(woosh.OP, '=', 726, 12, 726, 13),
woosh.Token(woosh.STRING, "'Group ID of the user who originally stored this member.'", 726, 14, 726, 71),
woosh.Token(woosh.OP, ',', 726, 71, 726, 72),
woosh.Token(woosh.NAME, 'size', 727, 8, 727, 12),
woosh.Token(woosh.OP, '=', 727, 13, 727, 14),
woosh.Token(woosh.STRING, "'Size in bytes.'", 727, 15, 727, 31),
woosh.Token(woosh.OP, ',', 727, 31, 727, 32),
woosh.Token(woosh.NAME, 'mtime', 728, 8, 728, 13),
woosh.Token(woosh.OP, '=', 728, 14, 728, 15),
woosh.Token(woosh.STRING, "'Time of last modification.'", 728, 16, 728, 44),
woosh.Token(woosh.OP, ',', 728, 44, 728, 45),
woosh.Token(woosh.NAME, 'chksum', 729, 8, 729, 14),
woosh.Token(woosh.OP, '=', 729, 15, 729, 16),
woosh.Token(woosh.STRING, "'Header checksum.'", 729, 17, 729, 35),
woosh.Token(woosh.OP, ',', 729, 35, 729, 36),
woosh.Token(woosh.NAME, 'type', 730, 8, 730, 12),
woosh.Token(woosh.OP, '=', 730, 13, 730, 14),
woosh.Token(woosh.OP, '(', 730, 15, 730, 16),
woosh.Token(woosh.STRING, "'File type. type is usually one of these constants: '", 730, 16, 730, 69),
woosh.Token(woosh.STRING, "'REGTYPE, AREGTYPE, LNKTYPE, SYMTYPE, DIRTYPE, FIFOTYPE, '", 731, 16, 731, 74),
woosh.Token(woosh.STRING, "'CONTTYPE, CHRTYPE, BLKTYPE, GNUTYPE_SPARSE.'", 732, 16, 732, 61),
woosh.Token(woosh.OP, ')', 732, 61, 732, 62),
woosh.Token(woosh.OP, ',', 732, 62, 732, 63),
woosh.Token(woosh.NAME, 'linkname', 733, 8, 733, 16),
woosh.Token(woosh.OP, '=', 733, 17, 733, 18),
woosh.Token(woosh.OP, '(', 733, 19, 733, 20),
woosh.Token(woosh.STRING, "'Name of the target file name, which is only present '", 733, 20, 733, 74),
woosh.Token(woosh.STRING, "'in TarInfo objects of type LNKTYPE and SYMTYPE.'", 734, 20, 734, 69),
woosh.Token(woosh.OP, ')', 734, 69, 734, 70),
woosh.Token(woosh.OP, ',', 734, 70, 734, 71),
woosh.Token(woosh.NAME, 'uname', 735, 8, 735, 13),
woosh.Token(woosh.OP, '=', 735, 14, 735, 15),
woosh.Token(woosh.STRING, "'User name.'", 735, 16, 735, 28),
woosh.Token(woosh.OP, ',', 735, 28, 735, 29),
woosh.Token(woosh.NAME, 'gname', 736, 8, 736, 13),
woosh.Token(woosh.OP, '=', 736, 14, 736, 15),
woosh.Token(woosh.STRING, "'Group name.'", 736, 16, 736, 29),
woosh.Token(woosh.OP, ',', 736, 29, 736, 30),
woosh.Token(woosh.NAME, 'devmajor', 737, 8, 737, 16),
woosh.Token(woosh.OP, '=', 737, 17, 737, 18),
woosh.Token(woosh.STRING, "'Device major number.'", 737, 19, 737, 41),
woosh.Token(woosh.OP, ',', 737, 41, 737, 42),
woosh.Token(woosh.NAME, 'devminor', 738, 8, 738, 16),
woosh.Token(woosh.OP, '=', 738, 17, 738, 18),
woosh.Token(woosh.STRING, "'Device minor number.'", 738, 19, 738, 41),
woosh.Token(woosh.OP, ',', 738, 41, 738, 42),
woosh.Token(woosh.NAME, 'offset', 739, 8, 739, 14),
woosh.Token(woosh.OP, '=', 739, 15, 739, 16),
woosh.Token(woosh.STRING, "'The tar header starts here.'", 739, 17, 739, 46),
woosh.Token(woosh.OP, ',', 739, 46, 739, 47),
woosh.Token(woosh.NAME, 'offset_data', 740, 8, 740, 19),
woosh.Token(woosh.OP, '=', 740, 20, 740, 21),
woosh.Token(woosh.STRING, '"The file\'s data starts here."', 740, 22, 740, 52),
woosh.Token(woosh.OP, ',', 740, 52, 740, 53),
woosh.Token(woosh.NAME, 'pax_headers', 741, 8, 741, 19),
woosh.Token(woosh.OP, '=', 741, 20, 741, 21),
woosh.Token(woosh.OP, '(', 741, 22, 741, 23),
woosh.Token(woosh.STRING, "'A dictionary containing key-value pairs of an '", 741, 23, 741, 71),
woosh.Token(woosh.STRING, "'associated pax extended header.'", 742, 23, 742, 56),
woosh.Token(woosh.OP, ')', 742, 56, 742, 57),
woosh.Token(woosh.OP, ',', 742, 57, 742, 58),
woosh.Token(woosh.NAME, 'sparse', 743, 8, 743, 14),
woosh.Token(woosh.OP, '=', 743, 15, 743, 16),
woosh.Token(woosh.STRING, "'Sparse member information.'", 743, 17, 743, 45),
woosh.Token(woosh.OP, ',', 743, 45, 743, 46),
woosh.Token(woosh.NAME, 'tarfile', 744, 8, 744, 15),
woosh.Token(woosh.OP, '=', 744, 16, 744, 17),
woosh.Token(woosh.NAME, 'None', 744, 18, 744, 22),
woosh.Token(woosh.OP, ',', 744, 22, 744, 23),
woosh.Token(woosh.NAME, '_sparse_structs', 745, 8, 745, 23),
woosh.Token(woosh.OP, '=', 745, 24, 745, 25),
woosh.Token(woosh.NAME, 'None', 745, 26, 745, 30),
woosh.Token(woosh.OP, ',', 745, 30, 745, 31),
woosh.Token(woosh.NAME, '_link_target', 746, 8, 746, 20),
woosh.Token(woosh.OP, '=', 746, 21, 746, 22),
woosh.Token(woosh.NAME, 'None', 746, 23, 746, 27),
woosh.Token(woosh.OP, ',', 746, 27, 746, 28),
woosh.Token(woosh.OP, ')', 747, 8, 747, 9),
woosh.Token(woosh.NEWLINE, '\r\n', 747, 9, 748, 0),
woosh.Token(woosh.NAME, 'def', 749, 4, 749, 7),
woosh.Token(woosh.NAME, '__init__', 749, 8, 749, 16),
woosh.Token(woosh.OP, '(', 749, 16, 749, 17),
woosh.Token(woosh.NAME, 'self', 749, 17, 749, 21),
woosh.Token(woosh.OP, ',', 749, 21, 749, 22),
woosh.Token(woosh.NAME, 'name', 749, 23, 749, 27),
woosh.Token(woosh.OP, '=', 749, 27, 749, 28),
woosh.Token(woosh.STRING, '""', 749, 28, 749, 30),
woosh.Token(woosh.OP, ')', 749, 30, 749, 31),
woosh.Token(woosh.OP, ':', 749, 31, 749, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 749, 32, 750, 0),
woosh.Token(woosh.INDENT, ' ', 750, 0, 750, 8),
woosh.Token(woosh.STRING, '"""Construct a TarInfo object. name is the optional name\r\n of the member.\r\n """', 750, 8, 752, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 752, 11, 753, 0),
woosh.Token(woosh.NAME, 'self', 753, 8, 753, 12),
woosh.Token(woosh.OP, '.', 753, 12, 753, 13),
woosh.Token(woosh.NAME, 'name', 753, 13, 753, 17),
woosh.Token(woosh.OP, '=', 753, 18, 753, 19),
woosh.Token(woosh.NAME, 'name', 753, 20, 753, 24),
woosh.Token(woosh.COMMENT, '# member name', 753, 32, 753, 45),
woosh.Token(woosh.NEWLINE, '\r\n', 753, 45, 754, 0),
woosh.Token(woosh.NAME, 'self', 754, 8, 754, 12),
woosh.Token(woosh.OP, '.', 754, 12, 754, 13),
woosh.Token(woosh.NAME, 'mode', 754, 13, 754, 17),
woosh.Token(woosh.OP, '=', 754, 18, 754, 19),
woosh.Token(woosh.NUMBER, '0o644', 754, 20, 754, 25),
woosh.Token(woosh.COMMENT, '# file permissions', 754, 32, 754, 50),
woosh.Token(woosh.NEWLINE, '\r\n', 754, 50, 755, 0),
woosh.Token(woosh.NAME, 'self', 755, 8, 755, 12),
woosh.Token(woosh.OP, '.', 755, 12, 755, 13),
woosh.Token(woosh.NAME, 'uid', 755, 13, 755, 16),
woosh.Token(woosh.OP, '=', 755, 17, 755, 18),
woosh.Token(woosh.NUMBER, '0', 755, 19, 755, 20),
woosh.Token(woosh.COMMENT, '# user id', 755, 32, 755, 41),
woosh.Token(woosh.NEWLINE, '\r\n', 755, 41, 756, 0),
woosh.Token(woosh.NAME, 'self', 756, 8, 756, 12),
woosh.Token(woosh.OP, '.', 756, 12, 756, 13),
woosh.Token(woosh.NAME, 'gid', 756, 13, 756, 16),
woosh.Token(woosh.OP, '=', 756, 17, 756, 18),
woosh.Token(woosh.NUMBER, '0', 756, 19, 756, 20),
woosh.Token(woosh.COMMENT, '# group id', 756, 32, 756, 42),
woosh.Token(woosh.NEWLINE, '\r\n', 756, 42, 757, 0),
woosh.Token(woosh.NAME, 'self', 757, 8, 757, 12),
woosh.Token(woosh.OP, '.', 757, 12, 757, 13),
woosh.Token(woosh.NAME, 'size', 757, 13, 757, 17),
woosh.Token(woosh.OP, '=', 757, 18, 757, 19),
woosh.Token(woosh.NUMBER, '0', 757, 20, 757, 21),
woosh.Token(woosh.COMMENT, '# file size', 757, 32, 757, 43),
woosh.Token(woosh.NEWLINE, '\r\n', 757, 43, 758, 0),
woosh.Token(woosh.NAME, 'self', 758, 8, 758, 12),
woosh.Token(woosh.OP, '.', 758, 12, 758, 13),
woosh.Token(woosh.NAME, 'mtime', 758, 13, 758, 18),
woosh.Token(woosh.OP, '=', 758, 19, 758, 20),
woosh.Token(woosh.NUMBER, '0', 758, 21, 758, 22),
woosh.Token(woosh.COMMENT, '# modification time', 758, 32, 758, 51),
woosh.Token(woosh.NEWLINE, '\r\n', 758, 51, 759, 0),
woosh.Token(woosh.NAME, 'self', 759, 8, 759, 12),
woosh.Token(woosh.OP, '.', 759, 12, 759, 13),
woosh.Token(woosh.NAME, 'chksum', 759, 13, 759, 19),
woosh.Token(woosh.OP, '=', 759, 20, 759, 21),
woosh.Token(woosh.NUMBER, '0', 759, 22, 759, 23),
woosh.Token(woosh.COMMENT, '# header checksum', 759, 32, 759, 49),
woosh.Token(woosh.NEWLINE, '\r\n', 759, 49, 760, 0),
woosh.Token(woosh.NAME, 'self', 760, 8, 760, 12),
woosh.Token(woosh.OP, '.', 760, 12, 760, 13),
woosh.Token(woosh.NAME, 'type', 760, 13, 760, 17),
woosh.Token(woosh.OP, '=', 760, 18, 760, 19),
woosh.Token(woosh.NAME, 'REGTYPE', 760, 20, 760, 27),
woosh.Token(woosh.COMMENT, '# member type', 760, 32, 760, 45),
woosh.Token(woosh.NEWLINE, '\r\n', 760, 45, 761, 0),
woosh.Token(woosh.NAME, 'self', 761, 8, 761, 12),
woosh.Token(woosh.OP, '.', 761, 12, 761, 13),
woosh.Token(woosh.NAME, 'linkname', 761, 13, 761, 21),
woosh.Token(woosh.OP, '=', 761, 22, 761, 23),
woosh.Token(woosh.STRING, '""', 761, 24, 761, 26),
woosh.Token(woosh.COMMENT, '# link name', 761, 32, 761, 43),
woosh.Token(woosh.NEWLINE, '\r\n', 761, 43, 762, 0),
woosh.Token(woosh.NAME, 'self', 762, 8, 762, 12),
woosh.Token(woosh.OP, '.', 762, 12, 762, 13),
woosh.Token(woosh.NAME, 'uname', 762, 13, 762, 18),
woosh.Token(woosh.OP, '=', 762, 19, 762, 20),
woosh.Token(woosh.STRING, '""', 762, 21, 762, 23),
woosh.Token(woosh.COMMENT, '# user name', 762, 32, 762, 43),
woosh.Token(woosh.NEWLINE, '\r\n', 762, 43, 763, 0),
woosh.Token(woosh.NAME, 'self', 763, 8, 763, 12),
woosh.Token(woosh.OP, '.', 763, 12, 763, 13),
woosh.Token(woosh.NAME, 'gname', 763, 13, 763, 18),
woosh.Token(woosh.OP, '=', 763, 19, 763, 20),
woosh.Token(woosh.STRING, '""', 763, 21, 763, 23),
woosh.Token(woosh.COMMENT, '# group name', 763, 32, 763, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 763, 44, 764, 0),
woosh.Token(woosh.NAME, 'self', 764, 8, 764, 12),
woosh.Token(woosh.OP, '.', 764, 12, 764, 13),
woosh.Token(woosh.NAME, 'devmajor', 764, 13, 764, 21),
woosh.Token(woosh.OP, '=', 764, 22, 764, 23),
woosh.Token(woosh.NUMBER, '0', 764, 24, 764, 25),
woosh.Token(woosh.COMMENT, '# device major number', 764, 32, 764, 53),
woosh.Token(woosh.NEWLINE, '\r\n', 764, 53, 765, 0),
woosh.Token(woosh.NAME, 'self', 765, 8, 765, 12),
woosh.Token(woosh.OP, '.', 765, 12, 765, 13),
woosh.Token(woosh.NAME, 'devminor', 765, 13, 765, 21),
woosh.Token(woosh.OP, '=', 765, 22, 765, 23),
woosh.Token(woosh.NUMBER, '0', 765, 24, 765, 25),
woosh.Token(woosh.COMMENT, '# device minor number', 765, 32, 765, 53),
woosh.Token(woosh.NEWLINE, '\r\n', 765, 53, 766, 0),
woosh.Token(woosh.NAME, 'self', 767, 8, 767, 12),
woosh.Token(woosh.OP, '.', 767, 12, 767, 13),
woosh.Token(woosh.NAME, 'offset', 767, 13, 767, 19),
woosh.Token(woosh.OP, '=', 767, 20, 767, 21),
woosh.Token(woosh.NUMBER, '0', 767, 22, 767, 23),
woosh.Token(woosh.COMMENT, '# the tar header starts here', 767, 32, 767, 60),
woosh.Token(woosh.NEWLINE, '\r\n', 767, 60, 768, 0),
woosh.Token(woosh.NAME, 'self', 768, 8, 768, 12),
woosh.Token(woosh.OP, '.', 768, 12, 768, 13),
woosh.Token(woosh.NAME, 'offset_data', 768, 13, 768, 24),
woosh.Token(woosh.OP, '=', 768, 25, 768, 26),
woosh.Token(woosh.NUMBER, '0', 768, 27, 768, 28),
woosh.Token(woosh.COMMENT, "# the file's data starts here", 768, 32, 768, 61),
woosh.Token(woosh.NEWLINE, '\r\n', 768, 61, 769, 0),
woosh.Token(woosh.NAME, 'self', 770, 8, 770, 12),
woosh.Token(woosh.OP, '.', 770, 12, 770, 13),
woosh.Token(woosh.NAME, 'sparse', 770, 13, 770, 19),
woosh.Token(woosh.OP, '=', 770, 20, 770, 21),
woosh.Token(woosh.NAME, 'None', 770, 22, 770, 26),
woosh.Token(woosh.COMMENT, '# sparse member information', 770, 32, 770, 59),
woosh.Token(woosh.NEWLINE, '\r\n', 770, 59, 771, 0),
woosh.Token(woosh.NAME, 'self', 771, 8, 771, 12),
woosh.Token(woosh.OP, '.', 771, 12, 771, 13),
woosh.Token(woosh.NAME, 'pax_headers', 771, 13, 771, 24),
woosh.Token(woosh.OP, '=', 771, 25, 771, 26),
woosh.Token(woosh.OP, '{', 771, 27, 771, 28),
woosh.Token(woosh.OP, '}', 771, 28, 771, 29),
woosh.Token(woosh.COMMENT, '# pax header information', 771, 32, 771, 56),
woosh.Token(woosh.NEWLINE, '\r\n', 771, 56, 772, 0),
woosh.Token(woosh.DEDENT, ' ', 773, 0, 773, 4),
woosh.Token(woosh.OP, '@', 773, 4, 773, 5),
woosh.Token(woosh.NAME, 'property', 773, 5, 773, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 773, 13, 774, 0),
woosh.Token(woosh.NAME, 'def', 774, 4, 774, 7),
woosh.Token(woosh.NAME, 'path', 774, 8, 774, 12),
woosh.Token(woosh.OP, '(', 774, 12, 774, 13),
woosh.Token(woosh.NAME, 'self', 774, 13, 774, 17),
woosh.Token(woosh.OP, ')', 774, 17, 774, 18),
woosh.Token(woosh.OP, ':', 774, 18, 774, 19),
woosh.Token(woosh.NEWLINE, '\r\n', 774, 19, 775, 0),
woosh.Token(woosh.INDENT, ' ', 775, 0, 775, 8),
woosh.Token(woosh.STRING, '\'In pax headers, "name" is called "path".\'', 775, 8, 775, 50),
woosh.Token(woosh.NEWLINE, '\r\n', 775, 50, 776, 0),
woosh.Token(woosh.NAME, 'return', 776, 8, 776, 14),
woosh.Token(woosh.NAME, 'self', 776, 15, 776, 19),
woosh.Token(woosh.OP, '.', 776, 19, 776, 20),
woosh.Token(woosh.NAME, 'name', 776, 20, 776, 24),
woosh.Token(woosh.NEWLINE, '\r\n', 776, 24, 777, 0),
woosh.Token(woosh.DEDENT, ' ', 778, 0, 778, 4),
woosh.Token(woosh.OP, '@', 778, 4, 778, 5),
woosh.Token(woosh.NAME, 'path', 778, 5, 778, 9),
woosh.Token(woosh.OP, '.', 778, 9, 778, 10),
woosh.Token(woosh.NAME, 'setter', 778, 10, 778, 16),
woosh.Token(woosh.NEWLINE, '\r\n', 778, 16, 779, 0),
woosh.Token(woosh.NAME, 'def', 779, 4, 779, 7),
woosh.Token(woosh.NAME, 'path', 779, 8, 779, 12),
woosh.Token(woosh.OP, '(', 779, 12, 779, 13),
woosh.Token(woosh.NAME, 'self', 779, 13, 779, 17),
woosh.Token(woosh.OP, ',', 779, 17, 779, 18),
woosh.Token(woosh.NAME, 'name', 779, 19, 779, 23),
woosh.Token(woosh.OP, ')', 779, 23, 779, 24),
woosh.Token(woosh.OP, ':', 779, 24, 779, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 779, 25, 780, 0),
woosh.Token(woosh.INDENT, ' ', 780, 0, 780, 8),
woosh.Token(woosh.NAME, 'self', 780, 8, 780, 12),
woosh.Token(woosh.OP, '.', 780, 12, 780, 13),
woosh.Token(woosh.NAME, 'name', 780, 13, 780, 17),
woosh.Token(woosh.OP, '=', 780, 18, 780, 19),
woosh.Token(woosh.NAME, 'name', 780, 20, 780, 24),
woosh.Token(woosh.NEWLINE, '\r\n', 780, 24, 781, 0),
woosh.Token(woosh.DEDENT, ' ', 782, 0, 782, 4),
woosh.Token(woosh.OP, '@', 782, 4, 782, 5),
woosh.Token(woosh.NAME, 'property', 782, 5, 782, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 782, 13, 783, 0),
woosh.Token(woosh.NAME, 'def', 783, 4, 783, 7),
woosh.Token(woosh.NAME, 'linkpath', 783, 8, 783, 16),
woosh.Token(woosh.OP, '(', 783, 16, 783, 17),
woosh.Token(woosh.NAME, 'self', 783, 17, 783, 21),
woosh.Token(woosh.OP, ')', 783, 21, 783, 22),
woosh.Token(woosh.OP, ':', 783, 22, 783, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 783, 23, 784, 0),
woosh.Token(woosh.INDENT, ' ', 784, 0, 784, 8),
woosh.Token(woosh.STRING, '\'In pax headers, "linkname" is called "linkpath".\'', 784, 8, 784, 58),
woosh.Token(woosh.NEWLINE, '\r\n', 784, 58, 785, 0),
woosh.Token(woosh.NAME, 'return', 785, 8, 785, 14),
woosh.Token(woosh.NAME, 'self', 785, 15, 785, 19),
woosh.Token(woosh.OP, '.', 785, 19, 785, 20),
woosh.Token(woosh.NAME, 'linkname', 785, 20, 785, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 785, 28, 786, 0),
woosh.Token(woosh.DEDENT, ' ', 787, 0, 787, 4),
woosh.Token(woosh.OP, '@', 787, 4, 787, 5),
woosh.Token(woosh.NAME, 'linkpath', 787, 5, 787, 13),
woosh.Token(woosh.OP, '.', 787, 13, 787, 14),
woosh.Token(woosh.NAME, 'setter', 787, 14, 787, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 787, 20, 788, 0),
woosh.Token(woosh.NAME, 'def', 788, 4, 788, 7),
woosh.Token(woosh.NAME, 'linkpath', 788, 8, 788, 16),
woosh.Token(woosh.OP, '(', 788, 16, 788, 17),
woosh.Token(woosh.NAME, 'self', 788, 17, 788, 21),
woosh.Token(woosh.OP, ',', 788, 21, 788, 22),
woosh.Token(woosh.NAME, 'linkname', 788, 23, 788, 31),
woosh.Token(woosh.OP, ')', 788, 31, 788, 32),
woosh.Token(woosh.OP, ':', 788, 32, 788, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 788, 33, 789, 0),
woosh.Token(woosh.INDENT, ' ', 789, 0, 789, 8),
woosh.Token(woosh.NAME, 'self', 789, 8, 789, 12),
woosh.Token(woosh.OP, '.', 789, 12, 789, 13),
woosh.Token(woosh.NAME, 'linkname', 789, 13, 789, 21),
woosh.Token(woosh.OP, '=', 789, 22, 789, 23),
woosh.Token(woosh.NAME, 'linkname', 789, 24, 789, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 789, 32, 790, 0),
woosh.Token(woosh.DEDENT, ' ', 791, 0, 791, 4),
woosh.Token(woosh.NAME, 'def', 791, 4, 791, 7),
woosh.Token(woosh.NAME, '__repr__', 791, 8, 791, 16),
woosh.Token(woosh.OP, '(', 791, 16, 791, 17),
woosh.Token(woosh.NAME, 'self', 791, 17, 791, 21),
woosh.Token(woosh.OP, ')', 791, 21, 791, 22),
woosh.Token(woosh.OP, ':', 791, 22, 791, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 791, 23, 792, 0),
woosh.Token(woosh.INDENT, ' ', 792, 0, 792, 8),
woosh.Token(woosh.NAME, 'return', 792, 8, 792, 14),
woosh.Token(woosh.STRING, '"<%s %r at %#x>"', 792, 15, 792, 31),
woosh.Token(woosh.OP, '%', 792, 32, 792, 33),
woosh.Token(woosh.OP, '(', 792, 34, 792, 35),
woosh.Token(woosh.NAME, 'self', 792, 35, 792, 39),
woosh.Token(woosh.OP, '.', 792, 39, 792, 40),
woosh.Token(woosh.NAME, '__class__', 792, 40, 792, 49),
woosh.Token(woosh.OP, '.', 792, 49, 792, 50),
woosh.Token(woosh.NAME, '__name__', 792, 50, 792, 58),
woosh.Token(woosh.OP, ',', 792, 58, 792, 59),
woosh.Token(woosh.NAME, 'self', 792, 59, 792, 63),
woosh.Token(woosh.OP, '.', 792, 63, 792, 64),
woosh.Token(woosh.NAME, 'name', 792, 64, 792, 68),
woosh.Token(woosh.OP, ',', 792, 68, 792, 69),
woosh.Token(woosh.NAME, 'id', 792, 69, 792, 71),
woosh.Token(woosh.OP, '(', 792, 71, 792, 72),
woosh.Token(woosh.NAME, 'self', 792, 72, 792, 76),
woosh.Token(woosh.OP, ')', 792, 76, 792, 77),
woosh.Token(woosh.OP, ')', 792, 77, 792, 78),
woosh.Token(woosh.NEWLINE, '\r\n', 792, 78, 793, 0),
woosh.Token(woosh.DEDENT, ' ', 794, 0, 794, 4),
woosh.Token(woosh.NAME, 'def', 794, 4, 794, 7),
woosh.Token(woosh.NAME, 'get_info', 794, 8, 794, 16),
woosh.Token(woosh.OP, '(', 794, 16, 794, 17),
woosh.Token(woosh.NAME, 'self', 794, 17, 794, 21),
woosh.Token(woosh.OP, ')', 794, 21, 794, 22),
woosh.Token(woosh.OP, ':', 794, 22, 794, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 794, 23, 795, 0),
woosh.Token(woosh.INDENT, ' ', 795, 0, 795, 8),
woosh.Token(woosh.STRING, '"""Return the TarInfo\'s attributes as a dictionary.\r\n """', 795, 8, 796, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 796, 11, 797, 0),
woosh.Token(woosh.NAME, 'info', 797, 8, 797, 12),
woosh.Token(woosh.OP, '=', 797, 13, 797, 14),
woosh.Token(woosh.OP, '{', 797, 15, 797, 16),
woosh.Token(woosh.STRING, '"name"', 798, 12, 798, 18),
woosh.Token(woosh.OP, ':', 798, 18, 798, 19),
woosh.Token(woosh.NAME, 'self', 798, 24, 798, 28),
woosh.Token(woosh.OP, '.', 798, 28, 798, 29),
woosh.Token(woosh.NAME, 'name', 798, 29, 798, 33),
woosh.Token(woosh.OP, ',', 798, 33, 798, 34),
woosh.Token(woosh.STRING, '"mode"', 799, 12, 799, 18),
woosh.Token(woosh.OP, ':', 799, 18, 799, 19),
woosh.Token(woosh.NAME, 'self', 799, 24, 799, 28),
woosh.Token(woosh.OP, '.', 799, 28, 799, 29),
woosh.Token(woosh.NAME, 'mode', 799, 29, 799, 33),
woosh.Token(woosh.OP, '&', 799, 34, 799, 35),
woosh.Token(woosh.NUMBER, '0o7777', 799, 36, 799, 42),
woosh.Token(woosh.OP, ',', 799, 42, 799, 43),
woosh.Token(woosh.STRING, '"uid"', 800, 12, 800, 17),
woosh.Token(woosh.OP, ':', 800, 17, 800, 18),
woosh.Token(woosh.NAME, 'self', 800, 24, 800, 28),
woosh.Token(woosh.OP, '.', 800, 28, 800, 29),
woosh.Token(woosh.NAME, 'uid', 800, 29, 800, 32),
woosh.Token(woosh.OP, ',', 800, 32, 800, 33),
woosh.Token(woosh.STRING, '"gid"', 801, 12, 801, 17),
woosh.Token(woosh.OP, ':', 801, 17, 801, 18),
woosh.Token(woosh.NAME, 'self', 801, 24, 801, 28),
woosh.Token(woosh.OP, '.', 801, 28, 801, 29),
woosh.Token(woosh.NAME, 'gid', 801, 29, 801, 32),
woosh.Token(woosh.OP, ',', 801, 32, 801, 33),
woosh.Token(woosh.STRING, '"size"', 802, 12, 802, 18),
woosh.Token(woosh.OP, ':', 802, 18, 802, 19),
woosh.Token(woosh.NAME, 'self', 802, 24, 802, 28),
woosh.Token(woosh.OP, '.', 802, 28, 802, 29),
woosh.Token(woosh.NAME, 'size', 802, 29, 802, 33),
woosh.Token(woosh.OP, ',', 802, 33, 802, 34),
woosh.Token(woosh.STRING, '"mtime"', 803, 12, 803, 19),
woosh.Token(woosh.OP, ':', 803, 19, 803, 20),
woosh.Token(woosh.NAME, 'self', 803, 24, 803, 28),
woosh.Token(woosh.OP, '.', 803, 28, 803, 29),
woosh.Token(woosh.NAME, 'mtime', 803, 29, 803, 34),
woosh.Token(woosh.OP, ',', 803, 34, 803, 35),
woosh.Token(woosh.STRING, '"chksum"', 804, 12, 804, 20),
woosh.Token(woosh.OP, ':', 804, 20, 804, 21),
woosh.Token(woosh.NAME, 'self', 804, 24, 804, 28),
woosh.Token(woosh.OP, '.', 804, 28, 804, 29),
woosh.Token(woosh.NAME, 'chksum', 804, 29, 804, 35),
woosh.Token(woosh.OP, ',', 804, 35, 804, 36),
woosh.Token(woosh.STRING, '"type"', 805, 12, 805, 18),
woosh.Token(woosh.OP, ':', 805, 18, 805, 19),
woosh.Token(woosh.NAME, 'self', 805, 24, 805, 28),
woosh.Token(woosh.OP, '.', 805, 28, 805, 29),
woosh.Token(woosh.NAME, 'type', 805, 29, 805, 33),
woosh.Token(woosh.OP, ',', 805, 33, 805, 34),
woosh.Token(woosh.STRING, '"linkname"', 806, 12, 806, 22),
woosh.Token(woosh.OP, ':', 806, 22, 806, 23),
woosh.Token(woosh.NAME, 'self', 806, 24, 806, 28),
woosh.Token(woosh.OP, '.', 806, 28, 806, 29),
woosh.Token(woosh.NAME, 'linkname', 806, 29, 806, 37),
woosh.Token(woosh.OP, ',', 806, 37, 806, 38),
woosh.Token(woosh.STRING, '"uname"', 807, 12, 807, 19),
woosh.Token(woosh.OP, ':', 807, 19, 807, 20),
woosh.Token(woosh.NAME, 'self', 807, 24, 807, 28),
woosh.Token(woosh.OP, '.', 807, 28, 807, 29),
woosh.Token(woosh.NAME, 'uname', 807, 29, 807, 34),
woosh.Token(woosh.OP, ',', 807, 34, 807, 35),
woosh.Token(woosh.STRING, '"gname"', 808, 12, 808, 19),
woosh.Token(woosh.OP, ':', 808, 19, 808, 20),
woosh.Token(woosh.NAME, 'self', 808, 24, 808, 28),
woosh.Token(woosh.OP, '.', 808, 28, 808, 29),
woosh.Token(woosh.NAME, 'gname', 808, 29, 808, 34),
woosh.Token(woosh.OP, ',', 808, 34, 808, 35),
woosh.Token(woosh.STRING, '"devmajor"', 809, 12, 809, 22),
woosh.Token(woosh.OP, ':', 809, 22, 809, 23),
woosh.Token(woosh.NAME, 'self', 809, 24, 809, 28),
woosh.Token(woosh.OP, '.', 809, 28, 809, 29),
woosh.Token(woosh.NAME, 'devmajor', 809, 29, 809, 37),
woosh.Token(woosh.OP, ',', 809, 37, 809, 38),
woosh.Token(woosh.STRING, '"devminor"', 810, 12, 810, 22),
woosh.Token(woosh.OP, ':', 810, 22, 810, 23),
woosh.Token(woosh.NAME, 'self', 810, 24, 810, 28),
woosh.Token(woosh.OP, '.', 810, 28, 810, 29),
woosh.Token(woosh.NAME, 'devminor', 810, 29, 810, 37),
woosh.Token(woosh.OP, '}', 811, 8, 811, 9),
woosh.Token(woosh.NEWLINE, '\r\n', 811, 9, 812, 0),
woosh.Token(woosh.NAME, 'if', 813, 8, 813, 10),
woosh.Token(woosh.NAME, 'info', 813, 11, 813, 15),
woosh.Token(woosh.OP, '[', 813, 15, 813, 16),
woosh.Token(woosh.STRING, '"type"', 813, 16, 813, 22),
woosh.Token(woosh.OP, ']', 813, 22, 813, 23),
woosh.Token(woosh.OP, '==', 813, 24, 813, 26),
woosh.Token(woosh.NAME, 'DIRTYPE', 813, 27, 813, 34),
woosh.Token(woosh.NAME, 'and', 813, 35, 813, 38),
woosh.Token(woosh.NAME, 'not', 813, 39, 813, 42),
woosh.Token(woosh.NAME, 'info', 813, 43, 813, 47),
woosh.Token(woosh.OP, '[', 813, 47, 813, 48),
woosh.Token(woosh.STRING, '"name"', 813, 48, 813, 54),
woosh.Token(woosh.OP, ']', 813, 54, 813, 55),
woosh.Token(woosh.OP, '.', 813, 55, 813, 56),
woosh.Token(woosh.NAME, 'endswith', 813, 56, 813, 64),
woosh.Token(woosh.OP, '(', 813, 64, 813, 65),
woosh.Token(woosh.STRING, '"/"', 813, 65, 813, 68),
woosh.Token(woosh.OP, ')', 813, 68, 813, 69),
woosh.Token(woosh.OP, ':', 813, 69, 813, 70),
woosh.Token(woosh.NEWLINE, '\r\n', 813, 70, 814, 0),
woosh.Token(woosh.INDENT, ' ', 814, 0, 814, 12),
woosh.Token(woosh.NAME, 'info', 814, 12, 814, 16),
woosh.Token(woosh.OP, '[', 814, 16, 814, 17),
woosh.Token(woosh.STRING, '"name"', 814, 17, 814, 23),
woosh.Token(woosh.OP, ']', 814, 23, 814, 24),
woosh.Token(woosh.OP, '+=', 814, 25, 814, 27),
woosh.Token(woosh.STRING, '"/"', 814, 28, 814, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 814, 31, 815, 0),
woosh.Token(woosh.DEDENT, ' ', 816, 0, 816, 8),
woosh.Token(woosh.NAME, 'return', 816, 8, 816, 14),
woosh.Token(woosh.NAME, 'info', 816, 15, 816, 19),
woosh.Token(woosh.NEWLINE, '\r\n', 816, 19, 817, 0),
woosh.Token(woosh.DEDENT, ' ', 818, 0, 818, 4),
woosh.Token(woosh.NAME, 'def', 818, 4, 818, 7),
woosh.Token(woosh.NAME, 'tobuf', 818, 8, 818, 13),
woosh.Token(woosh.OP, '(', 818, 13, 818, 14),
woosh.Token(woosh.NAME, 'self', 818, 14, 818, 18),
woosh.Token(woosh.OP, ',', 818, 18, 818, 19),
woosh.Token(woosh.NAME, 'format', 818, 20, 818, 26),
woosh.Token(woosh.OP, '=', 818, 26, 818, 27),
woosh.Token(woosh.NAME, 'DEFAULT_FORMAT', 818, 27, 818, 41),
woosh.Token(woosh.OP, ',', 818, 41, 818, 42),
woosh.Token(woosh.NAME, 'encoding', 818, 43, 818, 51),
woosh.Token(woosh.OP, '=', 818, 51, 818, 52),
woosh.Token(woosh.NAME, 'ENCODING', 818, 52, 818, 60),
woosh.Token(woosh.OP, ',', 818, 60, 818, 61),
woosh.Token(woosh.NAME, 'errors', 818, 62, 818, 68),
woosh.Token(woosh.OP, '=', 818, 68, 818, 69),
woosh.Token(woosh.STRING, '"surrogateescape"', 818, 69, 818, 86),
woosh.Token(woosh.OP, ')', 818, 86, 818, 87),
woosh.Token(woosh.OP, ':', 818, 87, 818, 88),
woosh.Token(woosh.NEWLINE, '\r\n', 818, 88, 819, 0),
woosh.Token(woosh.INDENT, ' ', 819, 0, 819, 8),
woosh.Token(woosh.STRING, '"""Return a tar header as a string of 512 byte blocks.\r\n """', 819, 8, 820, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 820, 11, 821, 0),
woosh.Token(woosh.NAME, 'info', 821, 8, 821, 12),
woosh.Token(woosh.OP, '=', 821, 13, 821, 14),
woosh.Token(woosh.NAME, 'self', 821, 15, 821, 19),
woosh.Token(woosh.OP, '.', 821, 19, 821, 20),
woosh.Token(woosh.NAME, 'get_info', 821, 20, 821, 28),
woosh.Token(woosh.OP, '(', 821, 28, 821, 29),
woosh.Token(woosh.OP, ')', 821, 29, 821, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 821, 30, 822, 0),
woosh.Token(woosh.NAME, 'if', 823, 8, 823, 10),
woosh.Token(woosh.NAME, 'format', 823, 11, 823, 17),
woosh.Token(woosh.OP, '==', 823, 18, 823, 20),
woosh.Token(woosh.NAME, 'USTAR_FORMAT', 823, 21, 823, 33),
woosh.Token(woosh.OP, ':', 823, 33, 823, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 823, 34, 824, 0),
woosh.Token(woosh.INDENT, ' ', 824, 0, 824, 12),
woosh.Token(woosh.NAME, 'return', 824, 12, 824, 18),
woosh.Token(woosh.NAME, 'self', 824, 19, 824, 23),
woosh.Token(woosh.OP, '.', 824, 23, 824, 24),
woosh.Token(woosh.NAME, 'create_ustar_header', 824, 24, 824, 43),
woosh.Token(woosh.OP, '(', 824, 43, 824, 44),
woosh.Token(woosh.NAME, 'info', 824, 44, 824, 48),
woosh.Token(woosh.OP, ',', 824, 48, 824, 49),
woosh.Token(woosh.NAME, 'encoding', 824, 50, 824, 58),
woosh.Token(woosh.OP, ',', 824, 58, 824, 59),
woosh.Token(woosh.NAME, 'errors', 824, 60, 824, 66),
woosh.Token(woosh.OP, ')', 824, 66, 824, 67),
woosh.Token(woosh.NEWLINE, '\r\n', 824, 67, 825, 0),
woosh.Token(woosh.DEDENT, ' ', 825, 0, 825, 8),
woosh.Token(woosh.NAME, 'elif', 825, 8, 825, 12),
woosh.Token(woosh.NAME, 'format', 825, 13, 825, 19),
woosh.Token(woosh.OP, '==', 825, 20, 825, 22),
woosh.Token(woosh.NAME, 'GNU_FORMAT', 825, 23, 825, 33),
woosh.Token(woosh.OP, ':', 825, 33, 825, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 825, 34, 826, 0),
woosh.Token(woosh.INDENT, ' ', 826, 0, 826, 12),
woosh.Token(woosh.NAME, 'return', 826, 12, 826, 18),
woosh.Token(woosh.NAME, 'self', 826, 19, 826, 23),
woosh.Token(woosh.OP, '.', 826, 23, 826, 24),
woosh.Token(woosh.NAME, 'create_gnu_header', 826, 24, 826, 41),
woosh.Token(woosh.OP, '(', 826, 41, 826, 42),
woosh.Token(woosh.NAME, 'info', 826, 42, 826, 46),
woosh.Token(woosh.OP, ',', 826, 46, 826, 47),
woosh.Token(woosh.NAME, 'encoding', 826, 48, 826, 56),
woosh.Token(woosh.OP, ',', 826, 56, 826, 57),
woosh.Token(woosh.NAME, 'errors', 826, 58, 826, 64),
woosh.Token(woosh.OP, ')', 826, 64, 826, 65),
woosh.Token(woosh.NEWLINE, '\r\n', 826, 65, 827, 0),
woosh.Token(woosh.DEDENT, ' ', 827, 0, 827, 8),
woosh.Token(woosh.NAME, 'elif', 827, 8, 827, 12),
woosh.Token(woosh.NAME, 'format', 827, 13, 827, 19),
woosh.Token(woosh.OP, '==', 827, 20, 827, 22),
woosh.Token(woosh.NAME, 'PAX_FORMAT', 827, 23, 827, 33),
woosh.Token(woosh.OP, ':', 827, 33, 827, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 827, 34, 828, 0),
woosh.Token(woosh.INDENT, ' ', 828, 0, 828, 12),
woosh.Token(woosh.NAME, 'return', 828, 12, 828, 18),
woosh.Token(woosh.NAME, 'self', 828, 19, 828, 23),
woosh.Token(woosh.OP, '.', 828, 23, 828, 24),
woosh.Token(woosh.NAME, 'create_pax_header', 828, 24, 828, 41),
woosh.Token(woosh.OP, '(', 828, 41, 828, 42),
woosh.Token(woosh.NAME, 'info', 828, 42, 828, 46),
woosh.Token(woosh.OP, ',', 828, 46, 828, 47),
woosh.Token(woosh.NAME, 'encoding', 828, 48, 828, 56),
woosh.Token(woosh.OP, ')', 828, 56, 828, 57),
woosh.Token(woosh.NEWLINE, '\r\n', 828, 57, 829, 0),
woosh.Token(woosh.DEDENT, ' ', 829, 0, 829, 8),
woosh.Token(woosh.NAME, 'else', 829, 8, 829, 12),
woosh.Token(woosh.OP, ':', 829, 12, 829, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 829, 13, 830, 0),
woosh.Token(woosh.INDENT, ' ', 830, 0, 830, 12),
woosh.Token(woosh.NAME, 'raise', 830, 12, 830, 17),
woosh.Token(woosh.NAME, 'ValueError', 830, 18, 830, 28),
woosh.Token(woosh.OP, '(', 830, 28, 830, 29),
woosh.Token(woosh.STRING, '"invalid format"', 830, 29, 830, 45),
woosh.Token(woosh.OP, ')', 830, 45, 830, 46),
woosh.Token(woosh.NEWLINE, '\r\n', 830, 46, 831, 0),
woosh.Token(woosh.DEDENT, ' ', 832, 0, 832, 4),
woosh.Token(woosh.DEDENT, '', 832, 4, 832, 4),
woosh.Token(woosh.NAME, 'def', 832, 4, 832, 7),
woosh.Token(woosh.NAME, 'create_ustar_header', 832, 8, 832, 27),
woosh.Token(woosh.OP, '(', 832, 27, 832, 28),
woosh.Token(woosh.NAME, 'self', 832, 28, 832, 32),
woosh.Token(woosh.OP, ',', 832, 32, 832, 33),
woosh.Token(woosh.NAME, 'info', 832, 34, 832, 38),
woosh.Token(woosh.OP, ',', 832, 38, 832, 39),
woosh.Token(woosh.NAME, 'encoding', 832, 40, 832, 48),
woosh.Token(woosh.OP, ',', 832, 48, 832, 49),
woosh.Token(woosh.NAME, 'errors', 832, 50, 832, 56),
woosh.Token(woosh.OP, ')', 832, 56, 832, 57),
woosh.Token(woosh.OP, ':', 832, 57, 832, 58),
woosh.Token(woosh.NEWLINE, '\r\n', 832, 58, 833, 0),
woosh.Token(woosh.INDENT, ' ', 833, 0, 833, 8),
woosh.Token(woosh.STRING, '"""Return the object as a ustar header block.\r\n """', 833, 8, 834, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 834, 11, 835, 0),
woosh.Token(woosh.NAME, 'info', 835, 8, 835, 12),
woosh.Token(woosh.OP, '[', 835, 12, 835, 13),
woosh.Token(woosh.STRING, '"magic"', 835, 13, 835, 20),
woosh.Token(woosh.OP, ']', 835, 20, 835, 21),
woosh.Token(woosh.OP, '=', 835, 22, 835, 23),
woosh.Token(woosh.NAME, 'POSIX_MAGIC', 835, 24, 835, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 835, 35, 836, 0),
woosh.Token(woosh.NAME, 'if', 837, 8, 837, 10),
woosh.Token(woosh.NAME, 'len', 837, 11, 837, 14),
woosh.Token(woosh.OP, '(', 837, 14, 837, 15),
woosh.Token(woosh.NAME, 'info', 837, 15, 837, 19),
woosh.Token(woosh.OP, '[', 837, 19, 837, 20),
woosh.Token(woosh.STRING, '"linkname"', 837, 20, 837, 30),
woosh.Token(woosh.OP, ']', 837, 30, 837, 31),
woosh.Token(woosh.OP, '.', 837, 31, 837, 32),
woosh.Token(woosh.NAME, 'encode', 837, 32, 837, 38),
woosh.Token(woosh.OP, '(', 837, 38, 837, 39),
woosh.Token(woosh.NAME, 'encoding', 837, 39, 837, 47),
woosh.Token(woosh.OP, ',', 837, 47, 837, 48),
woosh.Token(woosh.NAME, 'errors', 837, 49, 837, 55),
woosh.Token(woosh.OP, ')', 837, 55, 837, 56),
woosh.Token(woosh.OP, ')', 837, 56, 837, 57),
woosh.Token(woosh.OP, '>', 837, 58, 837, 59),
woosh.Token(woosh.NAME, 'LENGTH_LINK', 837, 60, 837, 71),
woosh.Token(woosh.OP, ':', 837, 71, 837, 72),
woosh.Token(woosh.NEWLINE, '\r\n', 837, 72, 838, 0),
woosh.Token(woosh.INDENT, ' ', 838, 0, 838, 12),
woosh.Token(woosh.NAME, 'raise', 838, 12, 838, 17),
woosh.Token(woosh.NAME, 'ValueError', 838, 18, 838, 28),
woosh.Token(woosh.OP, '(', 838, 28, 838, 29),
woosh.Token(woosh.STRING, '"linkname is too long"', 838, 29, 838, 51),
woosh.Token(woosh.OP, ')', 838, 51, 838, 52),
woosh.Token(woosh.NEWLINE, '\r\n', 838, 52, 839, 0),
woosh.Token(woosh.DEDENT, ' ', 840, 0, 840, 8),
woosh.Token(woosh.NAME, 'if', 840, 8, 840, 10),
woosh.Token(woosh.NAME, 'len', 840, 11, 840, 14),
woosh.Token(woosh.OP, '(', 840, 14, 840, 15),
woosh.Token(woosh.NAME, 'info', 840, 15, 840, 19),
woosh.Token(woosh.OP, '[', 840, 19, 840, 20),
woosh.Token(woosh.STRING, '"name"', 840, 20, 840, 26),
woosh.Token(woosh.OP, ']', 840, 26, 840, 27),
woosh.Token(woosh.OP, '.', 840, 27, 840, 28),
woosh.Token(woosh.NAME, 'encode', 840, 28, 840, 34),
woosh.Token(woosh.OP, '(', 840, 34, 840, 35),
woosh.Token(woosh.NAME, 'encoding', 840, 35, 840, 43),
woosh.Token(woosh.OP, ',', 840, 43, 840, 44),
woosh.Token(woosh.NAME, 'errors', 840, 45, 840, 51),
woosh.Token(woosh.OP, ')', 840, 51, 840, 52),
woosh.Token(woosh.OP, ')', 840, 52, 840, 53),
woosh.Token(woosh.OP, '>', 840, 54, 840, 55),
woosh.Token(woosh.NAME, 'LENGTH_NAME', 840, 56, 840, 67),
woosh.Token(woosh.OP, ':', 840, 67, 840, 68),
woosh.Token(woosh.NEWLINE, '\r\n', 840, 68, 841, 0),
woosh.Token(woosh.INDENT, ' ', 841, 0, 841, 12),
woosh.Token(woosh.NAME, 'info', 841, 12, 841, 16),
woosh.Token(woosh.OP, '[', 841, 16, 841, 17),
woosh.Token(woosh.STRING, '"prefix"', 841, 17, 841, 25),
woosh.Token(woosh.OP, ']', 841, 25, 841, 26),
woosh.Token(woosh.OP, ',', 841, 26, 841, 27),
woosh.Token(woosh.NAME, 'info', 841, 28, 841, 32),
woosh.Token(woosh.OP, '[', 841, 32, 841, 33),
woosh.Token(woosh.STRING, '"name"', 841, 33, 841, 39),
woosh.Token(woosh.OP, ']', 841, 39, 841, 40),
woosh.Token(woosh.OP, '=', 841, 41, 841, 42),
woosh.Token(woosh.NAME, 'self', 841, 43, 841, 47),
woosh.Token(woosh.OP, '.', 841, 47, 841, 48),
woosh.Token(woosh.NAME, '_posix_split_name', 841, 48, 841, 65),
woosh.Token(woosh.OP, '(', 841, 65, 841, 66),
woosh.Token(woosh.NAME, 'info', 841, 66, 841, 70),
woosh.Token(woosh.OP, '[', 841, 70, 841, 71),
woosh.Token(woosh.STRING, '"name"', 841, 71, 841, 77),
woosh.Token(woosh.OP, ']', 841, 77, 841, 78),
woosh.Token(woosh.OP, ',', 841, 78, 841, 79),
woosh.Token(woosh.NAME, 'encoding', 841, 80, 841, 88),
woosh.Token(woosh.OP, ',', 841, 88, 841, 89),
woosh.Token(woosh.NAME, 'errors', 841, 90, 841, 96),
woosh.Token(woosh.OP, ')', 841, 96, 841, 97),
woosh.Token(woosh.NEWLINE, '\r\n', 841, 97, 842, 0),
woosh.Token(woosh.DEDENT, ' ', 843, 0, 843, 8),
woosh.Token(woosh.NAME, 'return', 843, 8, 843, 14),
woosh.Token(woosh.NAME, 'self', 843, 15, 843, 19),
woosh.Token(woosh.OP, '.', 843, 19, 843, 20),
woosh.Token(woosh.NAME, '_create_header', 843, 20, 843, 34),
woosh.Token(woosh.OP, '(', 843, 34, 843, 35),
woosh.Token(woosh.NAME, 'info', 843, 35, 843, 39),
woosh.Token(woosh.OP, ',', 843, 39, 843, 40),
woosh.Token(woosh.NAME, 'USTAR_FORMAT', 843, 41, 843, 53),
woosh.Token(woosh.OP, ',', 843, 53, 843, 54),
woosh.Token(woosh.NAME, 'encoding', 843, 55, 843, 63),
woosh.Token(woosh.OP, ',', 843, 63, 843, 64),
woosh.Token(woosh.NAME, 'errors', 843, 65, 843, 71),
woosh.Token(woosh.OP, ')', 843, 71, 843, 72),
woosh.Token(woosh.NEWLINE, '\r\n', 843, 72, 844, 0),
woosh.Token(woosh.DEDENT, ' ', 845, 0, 845, 4),
woosh.Token(woosh.NAME, 'def', 845, 4, 845, 7),
woosh.Token(woosh.NAME, 'create_gnu_header', 845, 8, 845, 25),
woosh.Token(woosh.OP, '(', 845, 25, 845, 26),
woosh.Token(woosh.NAME, 'self', 845, 26, 845, 30),
woosh.Token(woosh.OP, ',', 845, 30, 845, 31),
woosh.Token(woosh.NAME, 'info', 845, 32, 845, 36),
woosh.Token(woosh.OP, ',', 845, 36, 845, 37),
woosh.Token(woosh.NAME, 'encoding', 845, 38, 845, 46),
woosh.Token(woosh.OP, ',', 845, 46, 845, 47),
woosh.Token(woosh.NAME, 'errors', 845, 48, 845, 54),
woosh.Token(woosh.OP, ')', 845, 54, 845, 55),
woosh.Token(woosh.OP, ':', 845, 55, 845, 56),
woosh.Token(woosh.NEWLINE, '\r\n', 845, 56, 846, 0),
woosh.Token(woosh.INDENT, ' ', 846, 0, 846, 8),
woosh.Token(woosh.STRING, '"""Return the object as a GNU header block sequence.\r\n """', 846, 8, 847, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 847, 11, 848, 0),
woosh.Token(woosh.NAME, 'info', 848, 8, 848, 12),
woosh.Token(woosh.OP, '[', 848, 12, 848, 13),
woosh.Token(woosh.STRING, '"magic"', 848, 13, 848, 20),
woosh.Token(woosh.OP, ']', 848, 20, 848, 21),
woosh.Token(woosh.OP, '=', 848, 22, 848, 23),
woosh.Token(woosh.NAME, 'GNU_MAGIC', 848, 24, 848, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 848, 33, 849, 0),
woosh.Token(woosh.NAME, 'buf', 850, 8, 850, 11),
woosh.Token(woosh.OP, '=', 850, 12, 850, 13),
woosh.Token(woosh.STRING, 'b""', 850, 14, 850, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 850, 17, 851, 0),
woosh.Token(woosh.NAME, 'if', 851, 8, 851, 10),
woosh.Token(woosh.NAME, 'len', 851, 11, 851, 14),
woosh.Token(woosh.OP, '(', 851, 14, 851, 15),
woosh.Token(woosh.NAME, 'info', 851, 15, 851, 19),
woosh.Token(woosh.OP, '[', 851, 19, 851, 20),
woosh.Token(woosh.STRING, '"linkname"', 851, 20, 851, 30),
woosh.Token(woosh.OP, ']', 851, 30, 851, 31),
woosh.Token(woosh.OP, '.', 851, 31, 851, 32),
woosh.Token(woosh.NAME, 'encode', 851, 32, 851, 38),
woosh.Token(woosh.OP, '(', 851, 38, 851, 39),
woosh.Token(woosh.NAME, 'encoding', 851, 39, 851, 47),
woosh.Token(woosh.OP, ',', 851, 47, 851, 48),
woosh.Token(woosh.NAME, 'errors', 851, 49, 851, 55),
woosh.Token(woosh.OP, ')', 851, 55, 851, 56),
woosh.Token(woosh.OP, ')', 851, 56, 851, 57),
woosh.Token(woosh.OP, '>', 851, 58, 851, 59),
woosh.Token(woosh.NAME, 'LENGTH_LINK', 851, 60, 851, 71),
woosh.Token(woosh.OP, ':', 851, 71, 851, 72),
woosh.Token(woosh.NEWLINE, '\r\n', 851, 72, 852, 0),
woosh.Token(woosh.INDENT, ' ', 852, 0, 852, 12),
woosh.Token(woosh.NAME, 'buf', 852, 12, 852, 15),
woosh.Token(woosh.OP, '+=', 852, 16, 852, 18),
woosh.Token(woosh.NAME, 'self', 852, 19, 852, 23),
woosh.Token(woosh.OP, '.', 852, 23, 852, 24),
woosh.Token(woosh.NAME, '_create_gnu_long_header', 852, 24, 852, 47),
woosh.Token(woosh.OP, '(', 852, 47, 852, 48),
woosh.Token(woosh.NAME, 'info', 852, 48, 852, 52),
woosh.Token(woosh.OP, '[', 852, 52, 852, 53),
woosh.Token(woosh.STRING, '"linkname"', 852, 53, 852, 63),
woosh.Token(woosh.OP, ']', 852, 63, 852, 64),
woosh.Token(woosh.OP, ',', 852, 64, 852, 65),
woosh.Token(woosh.NAME, 'GNUTYPE_LONGLINK', 852, 66, 852, 82),
woosh.Token(woosh.OP, ',', 852, 82, 852, 83),
woosh.Token(woosh.NAME, 'encoding', 852, 84, 852, 92),
woosh.Token(woosh.OP, ',', 852, 92, 852, 93),
woosh.Token(woosh.NAME, 'errors', 852, 94, 852, 100),
woosh.Token(woosh.OP, ')', 852, 100, 852, 101),
woosh.Token(woosh.NEWLINE, '\r\n', 852, 101, 853, 0),
woosh.Token(woosh.DEDENT, ' ', 854, 0, 854, 8),
woosh.Token(woosh.NAME, 'if', 854, 8, 854, 10),
woosh.Token(woosh.NAME, 'len', 854, 11, 854, 14),
woosh.Token(woosh.OP, '(', 854, 14, 854, 15),
woosh.Token(woosh.NAME, 'info', 854, 15, 854, 19),
woosh.Token(woosh.OP, '[', 854, 19, 854, 20),
woosh.Token(woosh.STRING, '"name"', 854, 20, 854, 26),
woosh.Token(woosh.OP, ']', 854, 26, 854, 27),
woosh.Token(woosh.OP, '.', 854, 27, 854, 28),
woosh.Token(woosh.NAME, 'encode', 854, 28, 854, 34),
woosh.Token(woosh.OP, '(', 854, 34, 854, 35),
woosh.Token(woosh.NAME, 'encoding', 854, 35, 854, 43),
woosh.Token(woosh.OP, ',', 854, 43, 854, 44),
woosh.Token(woosh.NAME, 'errors', 854, 45, 854, 51),
woosh.Token(woosh.OP, ')', 854, 51, 854, 52),
woosh.Token(woosh.OP, ')', 854, 52, 854, 53),
woosh.Token(woosh.OP, '>', 854, 54, 854, 55),
woosh.Token(woosh.NAME, 'LENGTH_NAME', 854, 56, 854, 67),
woosh.Token(woosh.OP, ':', 854, 67, 854, 68),
woosh.Token(woosh.NEWLINE, '\r\n', 854, 68, 855, 0),
woosh.Token(woosh.INDENT, ' ', 855, 0, 855, 12),
woosh.Token(woosh.NAME, 'buf', 855, 12, 855, 15),
woosh.Token(woosh.OP, '+=', 855, 16, 855, 18),
woosh.Token(woosh.NAME, 'self', 855, 19, 855, 23),
woosh.Token(woosh.OP, '.', 855, 23, 855, 24),
woosh.Token(woosh.NAME, '_create_gnu_long_header', 855, 24, 855, 47),
woosh.Token(woosh.OP, '(', 855, 47, 855, 48),
woosh.Token(woosh.NAME, 'info', 855, 48, 855, 52),
woosh.Token(woosh.OP, '[', 855, 52, 855, 53),
woosh.Token(woosh.STRING, '"name"', 855, 53, 855, 59),
woosh.Token(woosh.OP, ']', 855, 59, 855, 60),
woosh.Token(woosh.OP, ',', 855, 60, 855, 61),
woosh.Token(woosh.NAME, 'GNUTYPE_LONGNAME', 855, 62, 855, 78),
woosh.Token(woosh.OP, ',', 855, 78, 855, 79),
woosh.Token(woosh.NAME, 'encoding', 855, 80, 855, 88),
woosh.Token(woosh.OP, ',', 855, 88, 855, 89),
woosh.Token(woosh.NAME, 'errors', 855, 90, 855, 96),
woosh.Token(woosh.OP, ')', 855, 96, 855, 97),
woosh.Token(woosh.NEWLINE, '\r\n', 855, 97, 856, 0),
woosh.Token(woosh.DEDENT, ' ', 857, 0, 857, 8),
woosh.Token(woosh.NAME, 'return', 857, 8, 857, 14),
woosh.Token(woosh.NAME, 'buf', 857, 15, 857, 18),
woosh.Token(woosh.OP, '+', 857, 19, 857, 20),
woosh.Token(woosh.NAME, 'self', 857, 21, 857, 25),
woosh.Token(woosh.OP, '.', 857, 25, 857, 26),
woosh.Token(woosh.NAME, '_create_header', 857, 26, 857, 40),
woosh.Token(woosh.OP, '(', 857, 40, 857, 41),
woosh.Token(woosh.NAME, 'info', 857, 41, 857, 45),
woosh.Token(woosh.OP, ',', 857, 45, 857, 46),
woosh.Token(woosh.NAME, 'GNU_FORMAT', 857, 47, 857, 57),
woosh.Token(woosh.OP, ',', 857, 57, 857, 58),
woosh.Token(woosh.NAME, 'encoding', 857, 59, 857, 67),
woosh.Token(woosh.OP, ',', 857, 67, 857, 68),
woosh.Token(woosh.NAME, 'errors', 857, 69, 857, 75),
woosh.Token(woosh.OP, ')', 857, 75, 857, 76),
woosh.Token(woosh.NEWLINE, '\r\n', 857, 76, 858, 0),
woosh.Token(woosh.DEDENT, ' ', 859, 0, 859, 4),
woosh.Token(woosh.NAME, 'def', 859, 4, 859, 7),
woosh.Token(woosh.NAME, 'create_pax_header', 859, 8, 859, 25),
woosh.Token(woosh.OP, '(', 859, 25, 859, 26),
woosh.Token(woosh.NAME, 'self', 859, 26, 859, 30),
woosh.Token(woosh.OP, ',', 859, 30, 859, 31),
woosh.Token(woosh.NAME, 'info', 859, 32, 859, 36),
woosh.Token(woosh.OP, ',', 859, 36, 859, 37),
woosh.Token(woosh.NAME, 'encoding', 859, 38, 859, 46),
woosh.Token(woosh.OP, ')', 859, 46, 859, 47),
woosh.Token(woosh.OP, ':', 859, 47, 859, 48),
woosh.Token(woosh.NEWLINE, '\r\n', 859, 48, 860, 0),
woosh.Token(woosh.INDENT, ' ', 860, 0, 860, 8),
woosh.Token(woosh.STRING, '"""Return the object as a ustar header block. If it cannot be\r\n represented this way, prepend a pax extended header sequence\r\n with supplement information.\r\n """', 860, 8, 863, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 863, 11, 864, 0),
woosh.Token(woosh.NAME, 'info', 864, 8, 864, 12),
woosh.Token(woosh.OP, '[', 864, 12, 864, 13),
woosh.Token(woosh.STRING, '"magic"', 864, 13, 864, 20),
woosh.Token(woosh.OP, ']', 864, 20, 864, 21),
woosh.Token(woosh.OP, '=', 864, 22, 864, 23),
woosh.Token(woosh.NAME, 'POSIX_MAGIC', 864, 24, 864, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 864, 35, 865, 0),
woosh.Token(woosh.NAME, 'pax_headers', 865, 8, 865, 19),
woosh.Token(woosh.OP, '=', 865, 20, 865, 21),
woosh.Token(woosh.NAME, 'self', 865, 22, 865, 26),
woosh.Token(woosh.OP, '.', 865, 26, 865, 27),
woosh.Token(woosh.NAME, 'pax_headers', 865, 27, 865, 38),
woosh.Token(woosh.OP, '.', 865, 38, 865, 39),
woosh.Token(woosh.NAME, 'copy', 865, 39, 865, 43),
woosh.Token(woosh.OP, '(', 865, 43, 865, 44),
woosh.Token(woosh.OP, ')', 865, 44, 865, 45),
woosh.Token(woosh.NEWLINE, '\r\n', 865, 45, 866, 0),
woosh.Token(woosh.COMMENT, '# Test string fields for values that exceed the field length or cannot', 867, 8, 867, 78),
woosh.Token(woosh.COMMENT, '# be represented in ASCII encoding.', 868, 8, 868, 43),
woosh.Token(woosh.NAME, 'for', 869, 8, 869, 11),
woosh.Token(woosh.NAME, 'name', 869, 12, 869, 16),
woosh.Token(woosh.OP, ',', 869, 16, 869, 17),
woosh.Token(woosh.NAME, 'hname', 869, 18, 869, 23),
woosh.Token(woosh.OP, ',', 869, 23, 869, 24),
woosh.Token(woosh.NAME, 'length', 869, 25, 869, 31),
woosh.Token(woosh.NAME, 'in', 869, 32, 869, 34),
woosh.Token(woosh.OP, '(', 869, 35, 869, 36),
woosh.Token(woosh.OP, '(', 870, 16, 870, 17),
woosh.Token(woosh.STRING, '"name"', 870, 17, 870, 23),
woosh.Token(woosh.OP, ',', 870, 23, 870, 24),
woosh.Token(woosh.STRING, '"path"', 870, 25, 870, 31),
woosh.Token(woosh.OP, ',', 870, 31, 870, 32),
woosh.Token(woosh.NAME, 'LENGTH_NAME', 870, 33, 870, 44),
woosh.Token(woosh.OP, ')', 870, 44, 870, 45),
woosh.Token(woosh.OP, ',', 870, 45, 870, 46),
woosh.Token(woosh.OP, '(', 870, 47, 870, 48),
woosh.Token(woosh.STRING, '"linkname"', 870, 48, 870, 58),
woosh.Token(woosh.OP, ',', 870, 58, 870, 59),
woosh.Token(woosh.STRING, '"linkpath"', 870, 60, 870, 70),
woosh.Token(woosh.OP, ',', 870, 70, 870, 71),
woosh.Token(woosh.NAME, 'LENGTH_LINK', 870, 72, 870, 83),
woosh.Token(woosh.OP, ')', 870, 83, 870, 84),
woosh.Token(woosh.OP, ',', 870, 84, 870, 85),
woosh.Token(woosh.OP, '(', 871, 16, 871, 17),
woosh.Token(woosh.STRING, '"uname"', 871, 17, 871, 24),
woosh.Token(woosh.OP, ',', 871, 24, 871, 25),
woosh.Token(woosh.STRING, '"uname"', 871, 26, 871, 33),
woosh.Token(woosh.OP, ',', 871, 33, 871, 34),
woosh.Token(woosh.NUMBER, '32', 871, 35, 871, 37),
woosh.Token(woosh.OP, ')', 871, 37, 871, 38),
woosh.Token(woosh.OP, ',', 871, 38, 871, 39),
woosh.Token(woosh.OP, '(', 871, 40, 871, 41),
woosh.Token(woosh.STRING, '"gname"', 871, 41, 871, 48),
woosh.Token(woosh.OP, ',', 871, 48, 871, 49),
woosh.Token(woosh.STRING, '"gname"', 871, 50, 871, 57),
woosh.Token(woosh.OP, ',', 871, 57, 871, 58),
woosh.Token(woosh.NUMBER, '32', 871, 59, 871, 61),
woosh.Token(woosh.OP, ')', 871, 61, 871, 62),
woosh.Token(woosh.OP, ')', 871, 62, 871, 63),
woosh.Token(woosh.OP, ':', 871, 63, 871, 64),
woosh.Token(woosh.NEWLINE, '\r\n', 871, 64, 872, 0),
woosh.Token(woosh.INDENT, ' ', 873, 0, 873, 12),
woosh.Token(woosh.NAME, 'if', 873, 12, 873, 14),
woosh.Token(woosh.NAME, 'hname', 873, 15, 873, 20),
woosh.Token(woosh.NAME, 'in', 873, 21, 873, 23),
woosh.Token(woosh.NAME, 'pax_headers', 873, 24, 873, 35),
woosh.Token(woosh.OP, ':', 873, 35, 873, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 873, 36, 874, 0),
woosh.Token(woosh.COMMENT, '# The pax header has priority.', 874, 16, 874, 46),
woosh.Token(woosh.INDENT, ' ', 875, 0, 875, 16),
woosh.Token(woosh.NAME, 'continue', 875, 16, 875, 24),
woosh.Token(woosh.NEWLINE, '\r\n', 875, 24, 876, 0),
woosh.Token(woosh.COMMENT, '# Try to encode the string as ASCII.', 877, 12, 877, 48),
woosh.Token(woosh.DEDENT, ' ', 878, 0, 878, 12),
woosh.Token(woosh.NAME, 'try', 878, 12, 878, 15),
woosh.Token(woosh.OP, ':', 878, 15, 878, 16),
woosh.Token(woosh.NEWLINE, '\r\n', 878, 16, 879, 0),
woosh.Token(woosh.INDENT, ' ', 879, 0, 879, 16),
woosh.Token(woosh.NAME, 'info', 879, 16, 879, 20),
woosh.Token(woosh.OP, '[', 879, 20, 879, 21),
woosh.Token(woosh.NAME, 'name', 879, 21, 879, 25),
woosh.Token(woosh.OP, ']', 879, 25, 879, 26),
woosh.Token(woosh.OP, '.', 879, 26, 879, 27),
woosh.Token(woosh.NAME, 'encode', 879, 27, 879, 33),
woosh.Token(woosh.OP, '(', 879, 33, 879, 34),
woosh.Token(woosh.STRING, '"ascii"', 879, 34, 879, 41),
woosh.Token(woosh.OP, ',', 879, 41, 879, 42),
woosh.Token(woosh.STRING, '"strict"', 879, 43, 879, 51),
woosh.Token(woosh.OP, ')', 879, 51, 879, 52),
woosh.Token(woosh.NEWLINE, '\r\n', 879, 52, 880, 0),
woosh.Token(woosh.DEDENT, ' ', 880, 0, 880, 12),
woosh.Token(woosh.NAME, 'except', 880, 12, 880, 18),
woosh.Token(woosh.NAME, 'UnicodeEncodeError', 880, 19, 880, 37),
woosh.Token(woosh.OP, ':', 880, 37, 880, 38),
woosh.Token(woosh.NEWLINE, '\r\n', 880, 38, 881, 0),
woosh.Token(woosh.INDENT, ' ', 881, 0, 881, 16),
woosh.Token(woosh.NAME, 'pax_headers', 881, 16, 881, 27),
woosh.Token(woosh.OP, '[', 881, 27, 881, 28),
woosh.Token(woosh.NAME, 'hname', 881, 28, 881, 33),
woosh.Token(woosh.OP, ']', 881, 33, 881, 34),
woosh.Token(woosh.OP, '=', 881, 35, 881, 36),
woosh.Token(woosh.NAME, 'info', 881, 37, 881, 41),
woosh.Token(woosh.OP, '[', 881, 41, 881, 42),
woosh.Token(woosh.NAME, 'name', 881, 42, 881, 46),
woosh.Token(woosh.OP, ']', 881, 46, 881, 47),
woosh.Token(woosh.NEWLINE, '\r\n', 881, 47, 882, 0),
woosh.Token(woosh.NAME, 'continue', 882, 16, 882, 24),
woosh.Token(woosh.NEWLINE, '\r\n', 882, 24, 883, 0),
woosh.Token(woosh.DEDENT, ' ', 884, 0, 884, 12),
woosh.Token(woosh.NAME, 'if', 884, 12, 884, 14),
woosh.Token(woosh.NAME, 'len', 884, 15, 884, 18),
woosh.Token(woosh.OP, '(', 884, 18, 884, 19),
woosh.Token(woosh.NAME, 'info', 884, 19, 884, 23),
woosh.Token(woosh.OP, '[', 884, 23, 884, 24),
woosh.Token(woosh.NAME, 'name', 884, 24, 884, 28),
woosh.Token(woosh.OP, ']', 884, 28, 884, 29),
woosh.Token(woosh.OP, ')', 884, 29, 884, 30),
woosh.Token(woosh.OP, '>', 884, 31, 884, 32),
woosh.Token(woosh.NAME, 'length', 884, 33, 884, 39),
woosh.Token(woosh.OP, ':', 884, 39, 884, 40),
woosh.Token(woosh.NEWLINE, '\r\n', 884, 40, 885, 0),
woosh.Token(woosh.INDENT, ' ', 885, 0, 885, 16),
woosh.Token(woosh.NAME, 'pax_headers', 885, 16, 885, 27),
woosh.Token(woosh.OP, '[', 885, 27, 885, 28),
woosh.Token(woosh.NAME, 'hname', 885, 28, 885, 33),
woosh.Token(woosh.OP, ']', 885, 33, 885, 34),
woosh.Token(woosh.OP, '=', 885, 35, 885, 36),
woosh.Token(woosh.NAME, 'info', 885, 37, 885, 41),
woosh.Token(woosh.OP, '[', 885, 41, 885, 42),
woosh.Token(woosh.NAME, 'name', 885, 42, 885, 46),
woosh.Token(woosh.OP, ']', 885, 46, 885, 47),
woosh.Token(woosh.NEWLINE, '\r\n', 885, 47, 886, 0),
woosh.Token(woosh.COMMENT, '# Test number fields for values that exceed the field limit or values', 887, 8, 887, 77),
woosh.Token(woosh.COMMENT, '# that like to be stored as float.', 888, 8, 888, 42),
woosh.Token(woosh.DEDENT, ' ', 889, 0, 889, 8),
woosh.Token(woosh.DEDENT, '', 889, 8, 889, 8),
woosh.Token(woosh.NAME, 'for', 889, 8, 889, 11),
woosh.Token(woosh.NAME, 'name', 889, 12, 889, 16),
woosh.Token(woosh.OP, ',', 889, 16, 889, 17),
woosh.Token(woosh.NAME, 'digits', 889, 18, 889, 24),
woosh.Token(woosh.NAME, 'in', 889, 25, 889, 27),
woosh.Token(woosh.OP, '(', 889, 28, 889, 29),
woosh.Token(woosh.OP, '(', 889, 29, 889, 30),
woosh.Token(woosh.STRING, '"uid"', 889, 30, 889, 35),
woosh.Token(woosh.OP, ',', 889, 35, 889, 36),
woosh.Token(woosh.NUMBER, '8', 889, 37, 889, 38),
woosh.Token(woosh.OP, ')', 889, 38, 889, 39),
woosh.Token(woosh.OP, ',', 889, 39, 889, 40),
woosh.Token(woosh.OP, '(', 889, 41, 889, 42),
woosh.Token(woosh.STRING, '"gid"', 889, 42, 889, 47),
woosh.Token(woosh.OP, ',', 889, 47, 889, 48),
woosh.Token(woosh.NUMBER, '8', 889, 49, 889, 50),
woosh.Token(woosh.OP, ')', 889, 50, 889, 51),
woosh.Token(woosh.OP, ',', 889, 51, 889, 52),
woosh.Token(woosh.OP, '(', 889, 53, 889, 54),
woosh.Token(woosh.STRING, '"size"', 889, 54, 889, 60),
woosh.Token(woosh.OP, ',', 889, 60, 889, 61),
woosh.Token(woosh.NUMBER, '12', 889, 62, 889, 64),
woosh.Token(woosh.OP, ')', 889, 64, 889, 65),
woosh.Token(woosh.OP, ',', 889, 65, 889, 66),
woosh.Token(woosh.OP, '(', 889, 67, 889, 68),
woosh.Token(woosh.STRING, '"mtime"', 889, 68, 889, 75),
woosh.Token(woosh.OP, ',', 889, 75, 889, 76),
woosh.Token(woosh.NUMBER, '12', 889, 77, 889, 79),
woosh.Token(woosh.OP, ')', 889, 79, 889, 80),
woosh.Token(woosh.OP, ')', 889, 80, 889, 81),
woosh.Token(woosh.OP, ':', 889, 81, 889, 82),
woosh.Token(woosh.NEWLINE, '\r\n', 889, 82, 890, 0),
woosh.Token(woosh.INDENT, ' ', 890, 0, 890, 12),
woosh.Token(woosh.NAME, 'if', 890, 12, 890, 14),
woosh.Token(woosh.NAME, 'name', 890, 15, 890, 19),
woosh.Token(woosh.NAME, 'in', 890, 20, 890, 22),
woosh.Token(woosh.NAME, 'pax_headers', 890, 23, 890, 34),
woosh.Token(woosh.OP, ':', 890, 34, 890, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 890, 35, 891, 0),
woosh.Token(woosh.COMMENT, '# The pax header has priority. Avoid overflow.', 891, 16, 891, 62),
woosh.Token(woosh.INDENT, ' ', 892, 0, 892, 16),
woosh.Token(woosh.NAME, 'info', 892, 16, 892, 20),
woosh.Token(woosh.OP, '[', 892, 20, 892, 21),
woosh.Token(woosh.NAME, 'name', 892, 21, 892, 25),
woosh.Token(woosh.OP, ']', 892, 25, 892, 26),
woosh.Token(woosh.OP, '=', 892, 27, 892, 28),
woosh.Token(woosh.NUMBER, '0', 892, 29, 892, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 892, 30, 893, 0),
woosh.Token(woosh.NAME, 'continue', 893, 16, 893, 24),
woosh.Token(woosh.NEWLINE, '\r\n', 893, 24, 894, 0),
woosh.Token(woosh.DEDENT, ' ', 895, 0, 895, 12),
woosh.Token(woosh.NAME, 'val', 895, 12, 895, 15),
woosh.Token(woosh.OP, '=', 895, 16, 895, 17),
woosh.Token(woosh.NAME, 'info', 895, 18, 895, 22),
woosh.Token(woosh.OP, '[', 895, 22, 895, 23),
woosh.Token(woosh.NAME, 'name', 895, 23, 895, 27),
woosh.Token(woosh.OP, ']', 895, 27, 895, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 895, 28, 896, 0),
woosh.Token(woosh.NAME, 'if', 896, 12, 896, 14),
woosh.Token(woosh.NAME, 'not', 896, 15, 896, 18),
woosh.Token(woosh.NUMBER, '0', 896, 19, 896, 20),
woosh.Token(woosh.OP, '<=', 896, 21, 896, 23),
woosh.Token(woosh.NAME, 'val', 896, 24, 896, 27),
woosh.Token(woosh.OP, '<', 896, 28, 896, 29),
woosh.Token(woosh.NUMBER, '8', 896, 30, 896, 31),
woosh.Token(woosh.OP, '**', 896, 32, 896, 34),
woosh.Token(woosh.OP, '(', 896, 35, 896, 36),
woosh.Token(woosh.NAME, 'digits', 896, 36, 896, 42),
woosh.Token(woosh.OP, '-', 896, 43, 896, 44),
woosh.Token(woosh.NUMBER, '1', 896, 45, 896, 46),
woosh.Token(woosh.OP, ')', 896, 46, 896, 47),
woosh.Token(woosh.NAME, 'or', 896, 48, 896, 50),
woosh.Token(woosh.NAME, 'isinstance', 896, 51, 896, 61),
woosh.Token(woosh.OP, '(', 896, 61, 896, 62),
woosh.Token(woosh.NAME, 'val', 896, 62, 896, 65),
woosh.Token(woosh.OP, ',', 896, 65, 896, 66),
woosh.Token(woosh.NAME, 'float', 896, 67, 896, 72),
woosh.Token(woosh.OP, ')', 896, 72, 896, 73),
woosh.Token(woosh.OP, ':', 896, 73, 896, 74),
woosh.Token(woosh.NEWLINE, '\r\n', 896, 74, 897, 0),
woosh.Token(woosh.INDENT, ' ', 897, 0, 897, 16),
woosh.Token(woosh.NAME, 'pax_headers', 897, 16, 897, 27),
woosh.Token(woosh.OP, '[', 897, 27, 897, 28),
woosh.Token(woosh.NAME, 'name', 897, 28, 897, 32),
woosh.Token(woosh.OP, ']', 897, 32, 897, 33),
woosh.Token(woosh.OP, '=', 897, 34, 897, 35),
woosh.Token(woosh.NAME, 'str', 897, 36, 897, 39),
woosh.Token(woosh.OP, '(', 897, 39, 897, 40),
woosh.Token(woosh.NAME, 'val', 897, 40, 897, 43),
woosh.Token(woosh.OP, ')', 897, 43, 897, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 897, 44, 898, 0),
woosh.Token(woosh.NAME, 'info', 898, 16, 898, 20),
woosh.Token(woosh.OP, '[', 898, 20, 898, 21),
woosh.Token(woosh.NAME, 'name', 898, 21, 898, 25),
woosh.Token(woosh.OP, ']', 898, 25, 898, 26),
woosh.Token(woosh.OP, '=', 898, 27, 898, 28),
woosh.Token(woosh.NUMBER, '0', 898, 29, 898, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 898, 30, 899, 0),
woosh.Token(woosh.COMMENT, '# Create a pax extended header if necessary.', 900, 8, 900, 52),
woosh.Token(woosh.DEDENT, ' ', 901, 0, 901, 8),
woosh.Token(woosh.DEDENT, '', 901, 8, 901, 8),
woosh.Token(woosh.NAME, 'if', 901, 8, 901, 10),
woosh.Token(woosh.NAME, 'pax_headers', 901, 11, 901, 22),
woosh.Token(woosh.OP, ':', 901, 22, 901, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 901, 23, 902, 0),
woosh.Token(woosh.INDENT, ' ', 902, 0, 902, 12),
woosh.Token(woosh.NAME, 'buf', 902, 12, 902, 15),
woosh.Token(woosh.OP, '=', 902, 16, 902, 17),
woosh.Token(woosh.NAME, 'self', 902, 18, 902, 22),
woosh.Token(woosh.OP, '.', 902, 22, 902, 23),
woosh.Token(woosh.NAME, '_create_pax_generic_header', 902, 23, 902, 49),
woosh.Token(woosh.OP, '(', 902, 49, 902, 50),
woosh.Token(woosh.NAME, 'pax_headers', 902, 50, 902, 61),
woosh.Token(woosh.OP, ',', 902, 61, 902, 62),
woosh.Token(woosh.NAME, 'XHDTYPE', 902, 63, 902, 70),
woosh.Token(woosh.OP, ',', 902, 70, 902, 71),
woosh.Token(woosh.NAME, 'encoding', 902, 72, 902, 80),
woosh.Token(woosh.OP, ')', 902, 80, 902, 81),
woosh.Token(woosh.NEWLINE, '\r\n', 902, 81, 903, 0),
woosh.Token(woosh.DEDENT, ' ', 903, 0, 903, 8),
woosh.Token(woosh.NAME, 'else', 903, 8, 903, 12),
woosh.Token(woosh.OP, ':', 903, 12, 903, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 903, 13, 904, 0),
woosh.Token(woosh.INDENT, ' ', 904, 0, 904, 12),
woosh.Token(woosh.NAME, 'buf', 904, 12, 904, 15),
woosh.Token(woosh.OP, '=', 904, 16, 904, 17),
woosh.Token(woosh.STRING, 'b""', 904, 18, 904, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 904, 21, 905, 0),
woosh.Token(woosh.DEDENT, ' ', 906, 0, 906, 8),
woosh.Token(woosh.NAME, 'return', 906, 8, 906, 14),
woosh.Token(woosh.NAME, 'buf', 906, 15, 906, 18),
woosh.Token(woosh.OP, '+', 906, 19, 906, 20),
woosh.Token(woosh.NAME, 'self', 906, 21, 906, 25),
woosh.Token(woosh.OP, '.', 906, 25, 906, 26),
woosh.Token(woosh.NAME, '_create_header', 906, 26, 906, 40),
woosh.Token(woosh.OP, '(', 906, 40, 906, 41),
woosh.Token(woosh.NAME, 'info', 906, 41, 906, 45),
woosh.Token(woosh.OP, ',', 906, 45, 906, 46),
woosh.Token(woosh.NAME, 'USTAR_FORMAT', 906, 47, 906, 59),
woosh.Token(woosh.OP, ',', 906, 59, 906, 60),
woosh.Token(woosh.STRING, '"ascii"', 906, 61, 906, 68),
woosh.Token(woosh.OP, ',', 906, 68, 906, 69),
woosh.Token(woosh.STRING, '"replace"', 906, 70, 906, 79),
woosh.Token(woosh.OP, ')', 906, 79, 906, 80),
woosh.Token(woosh.NEWLINE, '\r\n', 906, 80, 907, 0),
woosh.Token(woosh.DEDENT, ' ', 908, 0, 908, 4),
woosh.Token(woosh.OP, '@', 908, 4, 908, 5),
woosh.Token(woosh.NAME, 'classmethod', 908, 5, 908, 16),
woosh.Token(woosh.NEWLINE, '\r\n', 908, 16, 909, 0),
woosh.Token(woosh.NAME, 'def', 909, 4, 909, 7),
woosh.Token(woosh.NAME, 'create_pax_global_header', 909, 8, 909, 32),
woosh.Token(woosh.OP, '(', 909, 32, 909, 33),
woosh.Token(woosh.NAME, 'cls', 909, 33, 909, 36),
woosh.Token(woosh.OP, ',', 909, 36, 909, 37),
woosh.Token(woosh.NAME, 'pax_headers', 909, 38, 909, 49),
woosh.Token(woosh.OP, ')', 909, 49, 909, 50),
woosh.Token(woosh.OP, ':', 909, 50, 909, 51),
woosh.Token(woosh.NEWLINE, '\r\n', 909, 51, 910, 0),
woosh.Token(woosh.INDENT, ' ', 910, 0, 910, 8),
woosh.Token(woosh.STRING, '"""Return the object as a pax global header block sequence.\r\n """', 910, 8, 911, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 911, 11, 912, 0),
woosh.Token(woosh.NAME, 'return', 912, 8, 912, 14),
woosh.Token(woosh.NAME, 'cls', 912, 15, 912, 18),
woosh.Token(woosh.OP, '.', 912, 18, 912, 19),
woosh.Token(woosh.NAME, '_create_pax_generic_header', 912, 19, 912, 45),
woosh.Token(woosh.OP, '(', 912, 45, 912, 46),
woosh.Token(woosh.NAME, 'pax_headers', 912, 46, 912, 57),
woosh.Token(woosh.OP, ',', 912, 57, 912, 58),
woosh.Token(woosh.NAME, 'XGLTYPE', 912, 59, 912, 66),
woosh.Token(woosh.OP, ',', 912, 66, 912, 67),
woosh.Token(woosh.STRING, '"utf-8"', 912, 68, 912, 75),
woosh.Token(woosh.OP, ')', 912, 75, 912, 76),
woosh.Token(woosh.NEWLINE, '\r\n', 912, 76, 913, 0),
woosh.Token(woosh.DEDENT, ' ', 914, 0, 914, 4),
woosh.Token(woosh.NAME, 'def', 914, 4, 914, 7),
woosh.Token(woosh.NAME, '_posix_split_name', 914, 8, 914, 25),
woosh.Token(woosh.OP, '(', 914, 25, 914, 26),
woosh.Token(woosh.NAME, 'self', 914, 26, 914, 30),
woosh.Token(woosh.OP, ',', 914, 30, 914, 31),
woosh.Token(woosh.NAME, 'name', 914, 32, 914, 36),
woosh.Token(woosh.OP, ',', 914, 36, 914, 37),
woosh.Token(woosh.NAME, 'encoding', 914, 38, 914, 46),
woosh.Token(woosh.OP, ',', 914, 46, 914, 47),
woosh.Token(woosh.NAME, 'errors', 914, 48, 914, 54),
woosh.Token(woosh.OP, ')', 914, 54, 914, 55),
woosh.Token(woosh.OP, ':', 914, 55, 914, 56),
woosh.Token(woosh.NEWLINE, '\r\n', 914, 56, 915, 0),
woosh.Token(woosh.INDENT, ' ', 915, 0, 915, 8),
woosh.Token(woosh.STRING, '"""Split a name longer than 100 chars into a prefix\r\n and a name part.\r\n """', 915, 8, 917, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 917, 11, 918, 0),
woosh.Token(woosh.NAME, 'components', 918, 8, 918, 18),
woosh.Token(woosh.OP, '=', 918, 19, 918, 20),
woosh.Token(woosh.NAME, 'name', 918, 21, 918, 25),
woosh.Token(woosh.OP, '.', 918, 25, 918, 26),
woosh.Token(woosh.NAME, 'split', 918, 26, 918, 31),
woosh.Token(woosh.OP, '(', 918, 31, 918, 32),
woosh.Token(woosh.STRING, '"/"', 918, 32, 918, 35),
woosh.Token(woosh.OP, ')', 918, 35, 918, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 918, 36, 919, 0),
woosh.Token(woosh.NAME, 'for', 919, 8, 919, 11),
woosh.Token(woosh.NAME, 'i', 919, 12, 919, 13),
woosh.Token(woosh.NAME, 'in', 919, 14, 919, 16),
woosh.Token(woosh.NAME, 'range', 919, 17, 919, 22),
woosh.Token(woosh.OP, '(', 919, 22, 919, 23),
woosh.Token(woosh.NUMBER, '1', 919, 23, 919, 24),
woosh.Token(woosh.OP, ',', 919, 24, 919, 25),
woosh.Token(woosh.NAME, 'len', 919, 26, 919, 29),
woosh.Token(woosh.OP, '(', 919, 29, 919, 30),
woosh.Token(woosh.NAME, 'components', 919, 30, 919, 40),
woosh.Token(woosh.OP, ')', 919, 40, 919, 41),
woosh.Token(woosh.OP, ')', 919, 41, 919, 42),
woosh.Token(woosh.OP, ':', 919, 42, 919, 43),
woosh.Token(woosh.NEWLINE, '\r\n', 919, 43, 920, 0),
woosh.Token(woosh.INDENT, ' ', 920, 0, 920, 12),
woosh.Token(woosh.NAME, 'prefix', 920, 12, 920, 18),
woosh.Token(woosh.OP, '=', 920, 19, 920, 20),
woosh.Token(woosh.STRING, '"/"', 920, 21, 920, 24),
woosh.Token(woosh.OP, '.', 920, 24, 920, 25),
woosh.Token(woosh.NAME, 'join', 920, 25, 920, 29),
woosh.Token(woosh.OP, '(', 920, 29, 920, 30),
woosh.Token(woosh.NAME, 'components', 920, 30, 920, 40),
woosh.Token(woosh.OP, '[', 920, 40, 920, 41),
woosh.Token(woosh.OP, ':', 920, 41, 920, 42),
woosh.Token(woosh.NAME, 'i', 920, 42, 920, 43),
woosh.Token(woosh.OP, ']', 920, 43, 920, 44),
woosh.Token(woosh.OP, ')', 920, 44, 920, 45),
woosh.Token(woosh.NEWLINE, '\r\n', 920, 45, 921, 0),
woosh.Token(woosh.NAME, 'name', 921, 12, 921, 16),
woosh.Token(woosh.OP, '=', 921, 17, 921, 18),
woosh.Token(woosh.STRING, '"/"', 921, 19, 921, 22),
woosh.Token(woosh.OP, '.', 921, 22, 921, 23),
woosh.Token(woosh.NAME, 'join', 921, 23, 921, 27),
woosh.Token(woosh.OP, '(', 921, 27, 921, 28),
woosh.Token(woosh.NAME, 'components', 921, 28, 921, 38),
woosh.Token(woosh.OP, '[', 921, 38, 921, 39),
woosh.Token(woosh.NAME, 'i', 921, 39, 921, 40),
woosh.Token(woosh.OP, ':', 921, 40, 921, 41),
woosh.Token(woosh.OP, ']', 921, 41, 921, 42),
woosh.Token(woosh.OP, ')', 921, 42, 921, 43),
woosh.Token(woosh.NEWLINE, '\r\n', 921, 43, 922, 0),
woosh.Token(woosh.NAME, 'if', 922, 12, 922, 14),
woosh.Token(woosh.NAME, 'len', 922, 15, 922, 18),
woosh.Token(woosh.OP, '(', 922, 18, 922, 19),
woosh.Token(woosh.NAME, 'prefix', 922, 19, 922, 25),
woosh.Token(woosh.OP, '.', 922, 25, 922, 26),
woosh.Token(woosh.NAME, 'encode', 922, 26, 922, 32),
woosh.Token(woosh.OP, '(', 922, 32, 922, 33),
woosh.Token(woosh.NAME, 'encoding', 922, 33, 922, 41),
woosh.Token(woosh.OP, ',', 922, 41, 922, 42),
woosh.Token(woosh.NAME, 'errors', 922, 43, 922, 49),
woosh.Token(woosh.OP, ')', 922, 49, 922, 50),
woosh.Token(woosh.OP, ')', 922, 50, 922, 51),
woosh.Token(woosh.OP, '<=', 922, 52, 922, 54),
woosh.Token(woosh.NAME, 'LENGTH_PREFIX', 922, 55, 922, 68),
woosh.Token(woosh.NAME, 'and', 922, 69, 922, 72),
woosh.Token(woosh.NAME, 'len', 923, 20, 923, 23),
woosh.Token(woosh.OP, '(', 923, 23, 923, 24),
woosh.Token(woosh.NAME, 'name', 923, 24, 923, 28),
woosh.Token(woosh.OP, '.', 923, 28, 923, 29),
woosh.Token(woosh.NAME, 'encode', 923, 29, 923, 35),
woosh.Token(woosh.OP, '(', 923, 35, 923, 36),
woosh.Token(woosh.NAME, 'encoding', 923, 36, 923, 44),
woosh.Token(woosh.OP, ',', 923, 44, 923, 45),
woosh.Token(woosh.NAME, 'errors', 923, 46, 923, 52),
woosh.Token(woosh.OP, ')', 923, 52, 923, 53),
woosh.Token(woosh.OP, ')', 923, 53, 923, 54),
woosh.Token(woosh.OP, '<=', 923, 55, 923, 57),
woosh.Token(woosh.NAME, 'LENGTH_NAME', 923, 58, 923, 69),
woosh.Token(woosh.OP, ':', 923, 69, 923, 70),
woosh.Token(woosh.NEWLINE, '\r\n', 923, 70, 924, 0),
woosh.Token(woosh.INDENT, ' ', 924, 0, 924, 16),
woosh.Token(woosh.NAME, 'break', 924, 16, 924, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 924, 21, 925, 0),
woosh.Token(woosh.DEDENT, ' ', 925, 0, 925, 8),
woosh.Token(woosh.DEDENT, '', 925, 8, 925, 8),
woosh.Token(woosh.NAME, 'else', 925, 8, 925, 12),
woosh.Token(woosh.OP, ':', 925, 12, 925, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 925, 13, 926, 0),
woosh.Token(woosh.INDENT, ' ', 926, 0, 926, 12),
woosh.Token(woosh.NAME, 'raise', 926, 12, 926, 17),
woosh.Token(woosh.NAME, 'ValueError', 926, 18, 926, 28),
woosh.Token(woosh.OP, '(', 926, 28, 926, 29),
woosh.Token(woosh.STRING, '"name is too long"', 926, 29, 926, 47),
woosh.Token(woosh.OP, ')', 926, 47, 926, 48),
woosh.Token(woosh.NEWLINE, '\r\n', 926, 48, 927, 0),
woosh.Token(woosh.DEDENT, ' ', 928, 0, 928, 8),
woosh.Token(woosh.NAME, 'return', 928, 8, 928, 14),
woosh.Token(woosh.NAME, 'prefix', 928, 15, 928, 21),
woosh.Token(woosh.OP, ',', 928, 21, 928, 22),
woosh.Token(woosh.NAME, 'name', 928, 23, 928, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 928, 27, 929, 0),
woosh.Token(woosh.DEDENT, ' ', 930, 0, 930, 4),
woosh.Token(woosh.OP, '@', 930, 4, 930, 5),
woosh.Token(woosh.NAME, 'staticmethod', 930, 5, 930, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 930, 17, 931, 0),
woosh.Token(woosh.NAME, 'def', 931, 4, 931, 7),
woosh.Token(woosh.NAME, '_create_header', 931, 8, 931, 22),
woosh.Token(woosh.OP, '(', 931, 22, 931, 23),
woosh.Token(woosh.NAME, 'info', 931, 23, 931, 27),
woosh.Token(woosh.OP, ',', 931, 27, 931, 28),
woosh.Token(woosh.NAME, 'format', 931, 29, 931, 35),
woosh.Token(woosh.OP, ',', 931, 35, 931, 36),
woosh.Token(woosh.NAME, 'encoding', 931, 37, 931, 45),
woosh.Token(woosh.OP, ',', 931, 45, 931, 46),
woosh.Token(woosh.NAME, 'errors', 931, 47, 931, 53),
woosh.Token(woosh.OP, ')', 931, 53, 931, 54),
woosh.Token(woosh.OP, ':', 931, 54, 931, 55),
woosh.Token(woosh.NEWLINE, '\r\n', 931, 55, 932, 0),
woosh.Token(woosh.INDENT, ' ', 932, 0, 932, 8),
woosh.Token(woosh.STRING, '"""Return a header block. info is a dictionary with file\r\n information, format must be one of the *_FORMAT constants.\r\n """', 932, 8, 934, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 934, 11, 935, 0),
woosh.Token(woosh.NAME, 'has_device_fields', 935, 8, 935, 25),
woosh.Token(woosh.OP, '=', 935, 26, 935, 27),
woosh.Token(woosh.NAME, 'info', 935, 28, 935, 32),
woosh.Token(woosh.OP, '.', 935, 32, 935, 33),
woosh.Token(woosh.NAME, 'get', 935, 33, 935, 36),
woosh.Token(woosh.OP, '(', 935, 36, 935, 37),
woosh.Token(woosh.STRING, '"type"', 935, 37, 935, 43),
woosh.Token(woosh.OP, ')', 935, 43, 935, 44),
woosh.Token(woosh.NAME, 'in', 935, 45, 935, 47),
woosh.Token(woosh.OP, '(', 935, 48, 935, 49),
woosh.Token(woosh.NAME, 'CHRTYPE', 935, 49, 935, 56),
woosh.Token(woosh.OP, ',', 935, 56, 935, 57),
woosh.Token(woosh.NAME, 'BLKTYPE', 935, 58, 935, 65),
woosh.Token(woosh.OP, ')', 935, 65, 935, 66),
woosh.Token(woosh.NEWLINE, '\r\n', 935, 66, 936, 0),
woosh.Token(woosh.NAME, 'if', 936, 8, 936, 10),
woosh.Token(woosh.NAME, 'has_device_fields', 936, 11, 936, 28),
woosh.Token(woosh.OP, ':', 936, 28, 936, 29),
woosh.Token(woosh.NEWLINE, '\r\n', 936, 29, 937, 0),
woosh.Token(woosh.INDENT, ' ', 937, 0, 937, 12),
woosh.Token(woosh.NAME, 'devmajor', 937, 12, 937, 20),
woosh.Token(woosh.OP, '=', 937, 21, 937, 22),
woosh.Token(woosh.NAME, 'itn', 937, 23, 937, 26),
woosh.Token(woosh.OP, '(', 937, 26, 937, 27),
woosh.Token(woosh.NAME, 'info', 937, 27, 937, 31),
woosh.Token(woosh.OP, '.', 937, 31, 937, 32),
woosh.Token(woosh.NAME, 'get', 937, 32, 937, 35),
woosh.Token(woosh.OP, '(', 937, 35, 937, 36),
woosh.Token(woosh.STRING, '"devmajor"', 937, 36, 937, 46),
woosh.Token(woosh.OP, ',', 937, 46, 937, 47),
woosh.Token(woosh.NUMBER, '0', 937, 48, 937, 49),
woosh.Token(woosh.OP, ')', 937, 49, 937, 50),
woosh.Token(woosh.OP, ',', 937, 50, 937, 51),
woosh.Token(woosh.NUMBER, '8', 937, 52, 937, 53),
woosh.Token(woosh.OP, ',', 937, 53, 937, 54),
woosh.Token(woosh.NAME, 'format', 937, 55, 937, 61),
woosh.Token(woosh.OP, ')', 937, 61, 937, 62),
woosh.Token(woosh.NEWLINE, '\r\n', 937, 62, 938, 0),
woosh.Token(woosh.NAME, 'devminor', 938, 12, 938, 20),
woosh.Token(woosh.OP, '=', 938, 21, 938, 22),
woosh.Token(woosh.NAME, 'itn', 938, 23, 938, 26),
woosh.Token(woosh.OP, '(', 938, 26, 938, 27),
woosh.Token(woosh.NAME, 'info', 938, 27, 938, 31),
woosh.Token(woosh.OP, '.', 938, 31, 938, 32),
woosh.Token(woosh.NAME, 'get', 938, 32, 938, 35),
woosh.Token(woosh.OP, '(', 938, 35, 938, 36),
woosh.Token(woosh.STRING, '"devminor"', 938, 36, 938, 46),
woosh.Token(woosh.OP, ',', 938, 46, 938, 47),
woosh.Token(woosh.NUMBER, '0', 938, 48, 938, 49),
woosh.Token(woosh.OP, ')', 938, 49, 938, 50),
woosh.Token(woosh.OP, ',', 938, 50, 938, 51),
woosh.Token(woosh.NUMBER, '8', 938, 52, 938, 53),
woosh.Token(woosh.OP, ',', 938, 53, 938, 54),
woosh.Token(woosh.NAME, 'format', 938, 55, 938, 61),
woosh.Token(woosh.OP, ')', 938, 61, 938, 62),
woosh.Token(woosh.NEWLINE, '\r\n', 938, 62, 939, 0),
woosh.Token(woosh.DEDENT, ' ', 939, 0, 939, 8),
woosh.Token(woosh.NAME, 'else', 939, 8, 939, 12),
woosh.Token(woosh.OP, ':', 939, 12, 939, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 939, 13, 940, 0),
woosh.Token(woosh.INDENT, ' ', 940, 0, 940, 12),
woosh.Token(woosh.NAME, 'devmajor', 940, 12, 940, 20),
woosh.Token(woosh.OP, '=', 940, 21, 940, 22),
woosh.Token(woosh.NAME, 'stn', 940, 23, 940, 26),
woosh.Token(woosh.OP, '(', 940, 26, 940, 27),
woosh.Token(woosh.STRING, '""', 940, 27, 940, 29),
woosh.Token(woosh.OP, ',', 940, 29, 940, 30),
woosh.Token(woosh.NUMBER, '8', 940, 31, 940, 32),
woosh.Token(woosh.OP, ',', 940, 32, 940, 33),
woosh.Token(woosh.NAME, 'encoding', 940, 34, 940, 42),
woosh.Token(woosh.OP, ',', 940, 42, 940, 43),
woosh.Token(woosh.NAME, 'errors', 940, 44, 940, 50),
woosh.Token(woosh.OP, ')', 940, 50, 940, 51),
woosh.Token(woosh.NEWLINE, '\r\n', 940, 51, 941, 0),
woosh.Token(woosh.NAME, 'devminor', 941, 12, 941, 20),
woosh.Token(woosh.OP, '=', 941, 21, 941, 22),
woosh.Token(woosh.NAME, 'stn', 941, 23, 941, 26),
woosh.Token(woosh.OP, '(', 941, 26, 941, 27),
woosh.Token(woosh.STRING, '""', 941, 27, 941, 29),
woosh.Token(woosh.OP, ',', 941, 29, 941, 30),
woosh.Token(woosh.NUMBER, '8', 941, 31, 941, 32),
woosh.Token(woosh.OP, ',', 941, 32, 941, 33),
woosh.Token(woosh.NAME, 'encoding', 941, 34, 941, 42),
woosh.Token(woosh.OP, ',', 941, 42, 941, 43),
woosh.Token(woosh.NAME, 'errors', 941, 44, 941, 50),
woosh.Token(woosh.OP, ')', 941, 50, 941, 51),
woosh.Token(woosh.NEWLINE, '\r\n', 941, 51, 942, 0),
woosh.Token(woosh.DEDENT, ' ', 943, 0, 943, 8),
woosh.Token(woosh.NAME, 'parts', 943, 8, 943, 13),
woosh.Token(woosh.OP, '=', 943, 14, 943, 15),
woosh.Token(woosh.OP, '[', 943, 16, 943, 17),
woosh.Token(woosh.NAME, 'stn', 944, 12, 944, 15),
woosh.Token(woosh.OP, '(', 944, 15, 944, 16),
woosh.Token(woosh.NAME, 'info', 944, 16, 944, 20),
woosh.Token(woosh.OP, '.', 944, 20, 944, 21),
woosh.Token(woosh.NAME, 'get', 944, 21, 944, 24),
woosh.Token(woosh.OP, '(', 944, 24, 944, 25),
woosh.Token(woosh.STRING, '"name"', 944, 25, 944, 31),
woosh.Token(woosh.OP, ',', 944, 31, 944, 32),
woosh.Token(woosh.STRING, '""', 944, 33, 944, 35),
woosh.Token(woosh.OP, ')', 944, 35, 944, 36),
woosh.Token(woosh.OP, ',', 944, 36, 944, 37),
woosh.Token(woosh.NUMBER, '100', 944, 38, 944, 41),
woosh.Token(woosh.OP, ',', 944, 41, 944, 42),
woosh.Token(woosh.NAME, 'encoding', 944, 43, 944, 51),
woosh.Token(woosh.OP, ',', 944, 51, 944, 52),
woosh.Token(woosh.NAME, 'errors', 944, 53, 944, 59),
woosh.Token(woosh.OP, ')', 944, 59, 944, 60),
woosh.Token(woosh.OP, ',', 944, 60, 944, 61),
woosh.Token(woosh.NAME, 'itn', 945, 12, 945, 15),
woosh.Token(woosh.OP, '(', 945, 15, 945, 16),
woosh.Token(woosh.NAME, 'info', 945, 16, 945, 20),
woosh.Token(woosh.OP, '.', 945, 20, 945, 21),
woosh.Token(woosh.NAME, 'get', 945, 21, 945, 24),
woosh.Token(woosh.OP, '(', 945, 24, 945, 25),
woosh.Token(woosh.STRING, '"mode"', 945, 25, 945, 31),
woosh.Token(woosh.OP, ',', 945, 31, 945, 32),
woosh.Token(woosh.NUMBER, '0', 945, 33, 945, 34),
woosh.Token(woosh.OP, ')', 945, 34, 945, 35),
woosh.Token(woosh.OP, '&', 945, 36, 945, 37),
woosh.Token(woosh.NUMBER, '0o7777', 945, 38, 945, 44),
woosh.Token(woosh.OP, ',', 945, 44, 945, 45),
woosh.Token(woosh.NUMBER, '8', 945, 46, 945, 47),
woosh.Token(woosh.OP, ',', 945, 47, 945, 48),
woosh.Token(woosh.NAME, 'format', 945, 49, 945, 55),
woosh.Token(woosh.OP, ')', 945, 55, 945, 56),
woosh.Token(woosh.OP, ',', 945, 56, 945, 57),
woosh.Token(woosh.NAME, 'itn', 946, 12, 946, 15),
woosh.Token(woosh.OP, '(', 946, 15, 946, 16),
woosh.Token(woosh.NAME, 'info', 946, 16, 946, 20),
woosh.Token(woosh.OP, '.', 946, 20, 946, 21),
woosh.Token(woosh.NAME, 'get', 946, 21, 946, 24),
woosh.Token(woosh.OP, '(', 946, 24, 946, 25),
woosh.Token(woosh.STRING, '"uid"', 946, 25, 946, 30),
woosh.Token(woosh.OP, ',', 946, 30, 946, 31),
woosh.Token(woosh.NUMBER, '0', 946, 32, 946, 33),
woosh.Token(woosh.OP, ')', 946, 33, 946, 34),
woosh.Token(woosh.OP, ',', 946, 34, 946, 35),
woosh.Token(woosh.NUMBER, '8', 946, 36, 946, 37),
woosh.Token(woosh.OP, ',', 946, 37, 946, 38),
woosh.Token(woosh.NAME, 'format', 946, 39, 946, 45),
woosh.Token(woosh.OP, ')', 946, 45, 946, 46),
woosh.Token(woosh.OP, ',', 946, 46, 946, 47),
woosh.Token(woosh.NAME, 'itn', 947, 12, 947, 15),
woosh.Token(woosh.OP, '(', 947, 15, 947, 16),
woosh.Token(woosh.NAME, 'info', 947, 16, 947, 20),
woosh.Token(woosh.OP, '.', 947, 20, 947, 21),
woosh.Token(woosh.NAME, 'get', 947, 21, 947, 24),
woosh.Token(woosh.OP, '(', 947, 24, 947, 25),
woosh.Token(woosh.STRING, '"gid"', 947, 25, 947, 30),
woosh.Token(woosh.OP, ',', 947, 30, 947, 31),
woosh.Token(woosh.NUMBER, '0', 947, 32, 947, 33),
woosh.Token(woosh.OP, ')', 947, 33, 947, 34),
woosh.Token(woosh.OP, ',', 947, 34, 947, 35),
woosh.Token(woosh.NUMBER, '8', 947, 36, 947, 37),
woosh.Token(woosh.OP, ',', 947, 37, 947, 38),
woosh.Token(woosh.NAME, 'format', 947, 39, 947, 45),
woosh.Token(woosh.OP, ')', 947, 45, 947, 46),
woosh.Token(woosh.OP, ',', 947, 46, 947, 47),
woosh.Token(woosh.NAME, 'itn', 948, 12, 948, 15),
woosh.Token(woosh.OP, '(', 948, 15, 948, 16),
woosh.Token(woosh.NAME, 'info', 948, 16, 948, 20),
woosh.Token(woosh.OP, '.', 948, 20, 948, 21),
woosh.Token(woosh.NAME, 'get', 948, 21, 948, 24),
woosh.Token(woosh.OP, '(', 948, 24, 948, 25),
woosh.Token(woosh.STRING, '"size"', 948, 25, 948, 31),
woosh.Token(woosh.OP, ',', 948, 31, 948, 32),
woosh.Token(woosh.NUMBER, '0', 948, 33, 948, 34),
woosh.Token(woosh.OP, ')', 948, 34, 948, 35),
woosh.Token(woosh.OP, ',', 948, 35, 948, 36),
woosh.Token(woosh.NUMBER, '12', 948, 37, 948, 39),
woosh.Token(woosh.OP, ',', 948, 39, 948, 40),
woosh.Token(woosh.NAME, 'format', 948, 41, 948, 47),
woosh.Token(woosh.OP, ')', 948, 47, 948, 48),
woosh.Token(woosh.OP, ',', 948, 48, 948, 49),
woosh.Token(woosh.NAME, 'itn', 949, 12, 949, 15),
woosh.Token(woosh.OP, '(', 949, 15, 949, 16),
woosh.Token(woosh.NAME, 'info', 949, 16, 949, 20),
woosh.Token(woosh.OP, '.', 949, 20, 949, 21),
woosh.Token(woosh.NAME, 'get', 949, 21, 949, 24),
woosh.Token(woosh.OP, '(', 949, 24, 949, 25),
woosh.Token(woosh.STRING, '"mtime"', 949, 25, 949, 32),
woosh.Token(woosh.OP, ',', 949, 32, 949, 33),
woosh.Token(woosh.NUMBER, '0', 949, 34, 949, 35),
woosh.Token(woosh.OP, ')', 949, 35, 949, 36),
woosh.Token(woosh.OP, ',', 949, 36, 949, 37),
woosh.Token(woosh.NUMBER, '12', 949, 38, 949, 40),
woosh.Token(woosh.OP, ',', 949, 40, 949, 41),
woosh.Token(woosh.NAME, 'format', 949, 42, 949, 48),
woosh.Token(woosh.OP, ')', 949, 48, 949, 49),
woosh.Token(woosh.OP, ',', 949, 49, 949, 50),
woosh.Token(woosh.STRING, 'b" "', 950, 12, 950, 23),
woosh.Token(woosh.OP, ',', 950, 23, 950, 24),
woosh.Token(woosh.COMMENT, '# checksum field', 950, 25, 950, 41),
woosh.Token(woosh.NAME, 'info', 951, 12, 951, 16),
woosh.Token(woosh.OP, '.', 951, 16, 951, 17),
woosh.Token(woosh.NAME, 'get', 951, 17, 951, 20),
woosh.Token(woosh.OP, '(', 951, 20, 951, 21),
woosh.Token(woosh.STRING, '"type"', 951, 21, 951, 27),
woosh.Token(woosh.OP, ',', 951, 27, 951, 28),
woosh.Token(woosh.NAME, 'REGTYPE', 951, 29, 951, 36),
woosh.Token(woosh.OP, ')', 951, 36, 951, 37),
woosh.Token(woosh.OP, ',', 951, 37, 951, 38),
woosh.Token(woosh.NAME, 'stn', 952, 12, 952, 15),
woosh.Token(woosh.OP, '(', 952, 15, 952, 16),
woosh.Token(woosh.NAME, 'info', 952, 16, 952, 20),
woosh.Token(woosh.OP, '.', 952, 20, 952, 21),
woosh.Token(woosh.NAME, 'get', 952, 21, 952, 24),
woosh.Token(woosh.OP, '(', 952, 24, 952, 25),
woosh.Token(woosh.STRING, '"linkname"', 952, 25, 952, 35),
woosh.Token(woosh.OP, ',', 952, 35, 952, 36),
woosh.Token(woosh.STRING, '""', 952, 37, 952, 39),
woosh.Token(woosh.OP, ')', 952, 39, 952, 40),
woosh.Token(woosh.OP, ',', 952, 40, 952, 41),
woosh.Token(woosh.NUMBER, '100', 952, 42, 952, 45),
woosh.Token(woosh.OP, ',', 952, 45, 952, 46),
woosh.Token(woosh.NAME, 'encoding', 952, 47, 952, 55),
woosh.Token(woosh.OP, ',', 952, 55, 952, 56),
woosh.Token(woosh.NAME, 'errors', 952, 57, 952, 63),
woosh.Token(woosh.OP, ')', 952, 63, 952, 64),
woosh.Token(woosh.OP, ',', 952, 64, 952, 65),
woosh.Token(woosh.NAME, 'info', 953, 12, 953, 16),
woosh.Token(woosh.OP, '.', 953, 16, 953, 17),
woosh.Token(woosh.NAME, 'get', 953, 17, 953, 20),
woosh.Token(woosh.OP, '(', 953, 20, 953, 21),
woosh.Token(woosh.STRING, '"magic"', 953, 21, 953, 28),
woosh.Token(woosh.OP, ',', 953, 28, 953, 29),
woosh.Token(woosh.NAME, 'POSIX_MAGIC', 953, 30, 953, 41),
woosh.Token(woosh.OP, ')', 953, 41, 953, 42),
woosh.Token(woosh.OP, ',', 953, 42, 953, 43),
woosh.Token(woosh.NAME, 'stn', 954, 12, 954, 15),
woosh.Token(woosh.OP, '(', 954, 15, 954, 16),
woosh.Token(woosh.NAME, 'info', 954, 16, 954, 20),
woosh.Token(woosh.OP, '.', 954, 20, 954, 21),
woosh.Token(woosh.NAME, 'get', 954, 21, 954, 24),
woosh.Token(woosh.OP, '(', 954, 24, 954, 25),
woosh.Token(woosh.STRING, '"uname"', 954, 25, 954, 32),
woosh.Token(woosh.OP, ',', 954, 32, 954, 33),
woosh.Token(woosh.STRING, '""', 954, 34, 954, 36),
woosh.Token(woosh.OP, ')', 954, 36, 954, 37),
woosh.Token(woosh.OP, ',', 954, 37, 954, 38),
woosh.Token(woosh.NUMBER, '32', 954, 39, 954, 41),
woosh.Token(woosh.OP, ',', 954, 41, 954, 42),
woosh.Token(woosh.NAME, 'encoding', 954, 43, 954, 51),
woosh.Token(woosh.OP, ',', 954, 51, 954, 52),
woosh.Token(woosh.NAME, 'errors', 954, 53, 954, 59),
woosh.Token(woosh.OP, ')', 954, 59, 954, 60),
woosh.Token(woosh.OP, ',', 954, 60, 954, 61),
woosh.Token(woosh.NAME, 'stn', 955, 12, 955, 15),
woosh.Token(woosh.OP, '(', 955, 15, 955, 16),
woosh.Token(woosh.NAME, 'info', 955, 16, 955, 20),
woosh.Token(woosh.OP, '.', 955, 20, 955, 21),
woosh.Token(woosh.NAME, 'get', 955, 21, 955, 24),
woosh.Token(woosh.OP, '(', 955, 24, 955, 25),
woosh.Token(woosh.STRING, '"gname"', 955, 25, 955, 32),
woosh.Token(woosh.OP, ',', 955, 32, 955, 33),
woosh.Token(woosh.STRING, '""', 955, 34, 955, 36),
woosh.Token(woosh.OP, ')', 955, 36, 955, 37),
woosh.Token(woosh.OP, ',', 955, 37, 955, 38),
woosh.Token(woosh.NUMBER, '32', 955, 39, 955, 41),
woosh.Token(woosh.OP, ',', 955, 41, 955, 42),
woosh.Token(woosh.NAME, 'encoding', 955, 43, 955, 51),
woosh.Token(woosh.OP, ',', 955, 51, 955, 52),
woosh.Token(woosh.NAME, 'errors', 955, 53, 955, 59),
woosh.Token(woosh.OP, ')', 955, 59, 955, 60),
woosh.Token(woosh.OP, ',', 955, 60, 955, 61),
woosh.Token(woosh.NAME, 'devmajor', 956, 12, 956, 20),
woosh.Token(woosh.OP, ',', 956, 20, 956, 21),
woosh.Token(woosh.NAME, 'devminor', 957, 12, 957, 20),
woosh.Token(woosh.OP, ',', 957, 20, 957, 21),
woosh.Token(woosh.NAME, 'stn', 958, 12, 958, 15),
woosh.Token(woosh.OP, '(', 958, 15, 958, 16),
woosh.Token(woosh.NAME, 'info', 958, 16, 958, 20),
woosh.Token(woosh.OP, '.', 958, 20, 958, 21),
woosh.Token(woosh.NAME, 'get', 958, 21, 958, 24),
woosh.Token(woosh.OP, '(', 958, 24, 958, 25),
woosh.Token(woosh.STRING, '"prefix"', 958, 25, 958, 33),
woosh.Token(woosh.OP, ',', 958, 33, 958, 34),
woosh.Token(woosh.STRING, '""', 958, 35, 958, 37),
woosh.Token(woosh.OP, ')', 958, 37, 958, 38),
woosh.Token(woosh.OP, ',', 958, 38, 958, 39),
woosh.Token(woosh.NUMBER, '155', 958, 40, 958, 43),
woosh.Token(woosh.OP, ',', 958, 43, 958, 44),
woosh.Token(woosh.NAME, 'encoding', 958, 45, 958, 53),
woosh.Token(woosh.OP, ',', 958, 53, 958, 54),
woosh.Token(woosh.NAME, 'errors', 958, 55, 958, 61),
woosh.Token(woosh.OP, ')', 958, 61, 958, 62),
woosh.Token(woosh.OP, ']', 959, 8, 959, 9),
woosh.Token(woosh.NEWLINE, '\r\n', 959, 9, 960, 0),
woosh.Token(woosh.NAME, 'buf', 961, 8, 961, 11),
woosh.Token(woosh.OP, '=', 961, 12, 961, 13),
woosh.Token(woosh.NAME, 'struct', 961, 14, 961, 20),
woosh.Token(woosh.OP, '.', 961, 20, 961, 21),
woosh.Token(woosh.NAME, 'pack', 961, 21, 961, 25),
woosh.Token(woosh.OP, '(', 961, 25, 961, 26),
woosh.Token(woosh.STRING, '"%ds"', 961, 26, 961, 31),
woosh.Token(woosh.OP, '%', 961, 32, 961, 33),
woosh.Token(woosh.NAME, 'BLOCKSIZE', 961, 34, 961, 43),
woosh.Token(woosh.OP, ',', 961, 43, 961, 44),
woosh.Token(woosh.STRING, 'b""', 961, 45, 961, 48),
woosh.Token(woosh.OP, '.', 961, 48, 961, 49),
woosh.Token(woosh.NAME, 'join', 961, 49, 961, 53),
woosh.Token(woosh.OP, '(', 961, 53, 961, 54),
woosh.Token(woosh.NAME, 'parts', 961, 54, 961, 59),
woosh.Token(woosh.OP, ')', 961, 59, 961, 60),
woosh.Token(woosh.OP, ')', 961, 60, 961, 61),
woosh.Token(woosh.NEWLINE, '\r\n', 961, 61, 962, 0),
woosh.Token(woosh.NAME, 'chksum', 962, 8, 962, 14),
woosh.Token(woosh.OP, '=', 962, 15, 962, 16),
woosh.Token(woosh.NAME, 'calc_chksums', 962, 17, 962, 29),
woosh.Token(woosh.OP, '(', 962, 29, 962, 30),
woosh.Token(woosh.NAME, 'buf', 962, 30, 962, 33),
woosh.Token(woosh.OP, '[', 962, 33, 962, 34),
woosh.Token(woosh.OP, '-', 962, 34, 962, 35),
woosh.Token(woosh.NAME, 'BLOCKSIZE', 962, 35, 962, 44),
woosh.Token(woosh.OP, ':', 962, 44, 962, 45),
woosh.Token(woosh.OP, ']', 962, 45, 962, 46),
woosh.Token(woosh.OP, ')', 962, 46, 962, 47),
woosh.Token(woosh.OP, '[', 962, 47, 962, 48),
woosh.Token(woosh.NUMBER, '0', 962, 48, 962, 49),
woosh.Token(woosh.OP, ']', 962, 49, 962, 50),
woosh.Token(woosh.NEWLINE, '\r\n', 962, 50, 963, 0),
woosh.Token(woosh.NAME, 'buf', 963, 8, 963, 11),
woosh.Token(woosh.OP, '=', 963, 12, 963, 13),
woosh.Token(woosh.NAME, 'buf', 963, 14, 963, 17),
woosh.Token(woosh.OP, '[', 963, 17, 963, 18),
woosh.Token(woosh.OP, ':', 963, 18, 963, 19),
woosh.Token(woosh.OP, '-', 963, 19, 963, 20),
woosh.Token(woosh.NUMBER, '364', 963, 20, 963, 23),
woosh.Token(woosh.OP, ']', 963, 23, 963, 24),
woosh.Token(woosh.OP, '+', 963, 25, 963, 26),
woosh.Token(woosh.NAME, 'bytes', 963, 27, 963, 32),
woosh.Token(woosh.OP, '(', 963, 32, 963, 33),
woosh.Token(woosh.STRING, '"%06o\\0"', 963, 33, 963, 41),
woosh.Token(woosh.OP, '%', 963, 42, 963, 43),
woosh.Token(woosh.NAME, 'chksum', 963, 44, 963, 50),
woosh.Token(woosh.OP, ',', 963, 50, 963, 51),
woosh.Token(woosh.STRING, '"ascii"', 963, 52, 963, 59),
woosh.Token(woosh.OP, ')', 963, 59, 963, 60),
woosh.Token(woosh.OP, '+', 963, 61, 963, 62),
woosh.Token(woosh.NAME, 'buf', 963, 63, 963, 66),
woosh.Token(woosh.OP, '[', 963, 66, 963, 67),
woosh.Token(woosh.OP, '-', 963, 67, 963, 68),
woosh.Token(woosh.NUMBER, '357', 963, 68, 963, 71),
woosh.Token(woosh.OP, ':', 963, 71, 963, 72),
woosh.Token(woosh.OP, ']', 963, 72, 963, 73),
woosh.Token(woosh.NEWLINE, '\r\n', 963, 73, 964, 0),
woosh.Token(woosh.NAME, 'return', 964, 8, 964, 14),
woosh.Token(woosh.NAME, 'buf', 964, 15, 964, 18),
woosh.Token(woosh.NEWLINE, '\r\n', 964, 18, 965, 0),
woosh.Token(woosh.DEDENT, ' ', 966, 0, 966, 4),
woosh.Token(woosh.OP, '@', 966, 4, 966, 5),
woosh.Token(woosh.NAME, 'staticmethod', 966, 5, 966, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 966, 17, 967, 0),
woosh.Token(woosh.NAME, 'def', 967, 4, 967, 7),
woosh.Token(woosh.NAME, '_create_payload', 967, 8, 967, 23),
woosh.Token(woosh.OP, '(', 967, 23, 967, 24),
woosh.Token(woosh.NAME, 'payload', 967, 24, 967, 31),
woosh.Token(woosh.OP, ')', 967, 31, 967, 32),
woosh.Token(woosh.OP, ':', 967, 32, 967, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 967, 33, 968, 0),
woosh.Token(woosh.INDENT, ' ', 968, 0, 968, 8),
woosh.Token(woosh.STRING, '"""Return the string payload filled with zero bytes\r\n up to the next 512 byte border.\r\n """', 968, 8, 970, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 970, 11, 971, 0),
woosh.Token(woosh.NAME, 'blocks', 971, 8, 971, 14),
woosh.Token(woosh.OP, ',', 971, 14, 971, 15),
woosh.Token(woosh.NAME, 'remainder', 971, 16, 971, 25),
woosh.Token(woosh.OP, '=', 971, 26, 971, 27),
woosh.Token(woosh.NAME, 'divmod', 971, 28, 971, 34),
woosh.Token(woosh.OP, '(', 971, 34, 971, 35),
woosh.Token(woosh.NAME, 'len', 971, 35, 971, 38),
woosh.Token(woosh.OP, '(', 971, 38, 971, 39),
woosh.Token(woosh.NAME, 'payload', 971, 39, 971, 46),
woosh.Token(woosh.OP, ')', 971, 46, 971, 47),
woosh.Token(woosh.OP, ',', 971, 47, 971, 48),
woosh.Token(woosh.NAME, 'BLOCKSIZE', 971, 49, 971, 58),
woosh.Token(woosh.OP, ')', 971, 58, 971, 59),
woosh.Token(woosh.NEWLINE, '\r\n', 971, 59, 972, 0),
woosh.Token(woosh.NAME, 'if', 972, 8, 972, 10),
woosh.Token(woosh.NAME, 'remainder', 972, 11, 972, 20),
woosh.Token(woosh.OP, '>', 972, 21, 972, 22),
woosh.Token(woosh.NUMBER, '0', 972, 23, 972, 24),
woosh.Token(woosh.OP, ':', 972, 24, 972, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 972, 25, 973, 0),
woosh.Token(woosh.INDENT, ' ', 973, 0, 973, 12),
woosh.Token(woosh.NAME, 'payload', 973, 12, 973, 19),
woosh.Token(woosh.OP, '+=', 973, 20, 973, 22),
woosh.Token(woosh.OP, '(', 973, 23, 973, 24),
woosh.Token(woosh.NAME, 'BLOCKSIZE', 973, 24, 973, 33),
woosh.Token(woosh.OP, '-', 973, 34, 973, 35),
woosh.Token(woosh.NAME, 'remainder', 973, 36, 973, 45),
woosh.Token(woosh.OP, ')', 973, 45, 973, 46),
woosh.Token(woosh.OP, '*', 973, 47, 973, 48),
woosh.Token(woosh.NAME, 'NUL', 973, 49, 973, 52),
woosh.Token(woosh.NEWLINE, '\r\n', 973, 52, 974, 0),
woosh.Token(woosh.DEDENT, ' ', 974, 0, 974, 8),
woosh.Token(woosh.NAME, 'return', 974, 8, 974, 14),
woosh.Token(woosh.NAME, 'payload', 974, 15, 974, 22),
woosh.Token(woosh.NEWLINE, '\r\n', 974, 22, 975, 0),
woosh.Token(woosh.DEDENT, ' ', 976, 0, 976, 4),
woosh.Token(woosh.OP, '@', 976, 4, 976, 5),
woosh.Token(woosh.NAME, 'classmethod', 976, 5, 976, 16),
woosh.Token(woosh.NEWLINE, '\r\n', 976, 16, 977, 0),
woosh.Token(woosh.NAME, 'def', 977, 4, 977, 7),
woosh.Token(woosh.NAME, '_create_gnu_long_header', 977, 8, 977, 31),
woosh.Token(woosh.OP, '(', 977, 31, 977, 32),
woosh.Token(woosh.NAME, 'cls', 977, 32, 977, 35),
woosh.Token(woosh.OP, ',', 977, 35, 977, 36),
woosh.Token(woosh.NAME, 'name', 977, 37, 977, 41),
woosh.Token(woosh.OP, ',', 977, 41, 977, 42),
woosh.Token(woosh.NAME, 'type', 977, 43, 977, 47),
woosh.Token(woosh.OP, ',', 977, 47, 977, 48),
woosh.Token(woosh.NAME, 'encoding', 977, 49, 977, 57),
woosh.Token(woosh.OP, ',', 977, 57, 977, 58),
woosh.Token(woosh.NAME, 'errors', 977, 59, 977, 65),
woosh.Token(woosh.OP, ')', 977, 65, 977, 66),
woosh.Token(woosh.OP, ':', 977, 66, 977, 67),
woosh.Token(woosh.NEWLINE, '\r\n', 977, 67, 978, 0),
woosh.Token(woosh.INDENT, ' ', 978, 0, 978, 8),
woosh.Token(woosh.STRING, '"""Return a GNUTYPE_LONGNAME or GNUTYPE_LONGLINK sequence\r\n for name.\r\n """', 978, 8, 980, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 980, 11, 981, 0),
woosh.Token(woosh.NAME, 'name', 981, 8, 981, 12),
woosh.Token(woosh.OP, '=', 981, 13, 981, 14),
woosh.Token(woosh.NAME, 'name', 981, 15, 981, 19),
woosh.Token(woosh.OP, '.', 981, 19, 981, 20),
woosh.Token(woosh.NAME, 'encode', 981, 20, 981, 26),
woosh.Token(woosh.OP, '(', 981, 26, 981, 27),
woosh.Token(woosh.NAME, 'encoding', 981, 27, 981, 35),
woosh.Token(woosh.OP, ',', 981, 35, 981, 36),
woosh.Token(woosh.NAME, 'errors', 981, 37, 981, 43),
woosh.Token(woosh.OP, ')', 981, 43, 981, 44),
woosh.Token(woosh.OP, '+', 981, 45, 981, 46),
woosh.Token(woosh.NAME, 'NUL', 981, 47, 981, 50),
woosh.Token(woosh.NEWLINE, '\r\n', 981, 50, 982, 0),
woosh.Token(woosh.NAME, 'info', 983, 8, 983, 12),
woosh.Token(woosh.OP, '=', 983, 13, 983, 14),
woosh.Token(woosh.OP, '{', 983, 15, 983, 16),
woosh.Token(woosh.OP, '}', 983, 16, 983, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 983, 17, 984, 0),
woosh.Token(woosh.NAME, 'info', 984, 8, 984, 12),
woosh.Token(woosh.OP, '[', 984, 12, 984, 13),
woosh.Token(woosh.STRING, '"name"', 984, 13, 984, 19),
woosh.Token(woosh.OP, ']', 984, 19, 984, 20),
woosh.Token(woosh.OP, '=', 984, 21, 984, 22),
woosh.Token(woosh.STRING, '"././@LongLink"', 984, 23, 984, 38),
woosh.Token(woosh.NEWLINE, '\r\n', 984, 38, 985, 0),
woosh.Token(woosh.NAME, 'info', 985, 8, 985, 12),
woosh.Token(woosh.OP, '[', 985, 12, 985, 13),
woosh.Token(woosh.STRING, '"type"', 985, 13, 985, 19),
woosh.Token(woosh.OP, ']', 985, 19, 985, 20),
woosh.Token(woosh.OP, '=', 985, 21, 985, 22),
woosh.Token(woosh.NAME, 'type', 985, 23, 985, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 985, 27, 986, 0),
woosh.Token(woosh.NAME, 'info', 986, 8, 986, 12),
woosh.Token(woosh.OP, '[', 986, 12, 986, 13),
woosh.Token(woosh.STRING, '"size"', 986, 13, 986, 19),
woosh.Token(woosh.OP, ']', 986, 19, 986, 20),
woosh.Token(woosh.OP, '=', 986, 21, 986, 22),
woosh.Token(woosh.NAME, 'len', 986, 23, 986, 26),
woosh.Token(woosh.OP, '(', 986, 26, 986, 27),
woosh.Token(woosh.NAME, 'name', 986, 27, 986, 31),
woosh.Token(woosh.OP, ')', 986, 31, 986, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 986, 32, 987, 0),
woosh.Token(woosh.NAME, 'info', 987, 8, 987, 12),
woosh.Token(woosh.OP, '[', 987, 12, 987, 13),
woosh.Token(woosh.STRING, '"magic"', 987, 13, 987, 20),
woosh.Token(woosh.OP, ']', 987, 20, 987, 21),
woosh.Token(woosh.OP, '=', 987, 22, 987, 23),
woosh.Token(woosh.NAME, 'GNU_MAGIC', 987, 24, 987, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 987, 33, 988, 0),
woosh.Token(woosh.COMMENT, '# create extended header + name blocks.', 989, 8, 989, 47),
woosh.Token(woosh.NAME, 'return', 990, 8, 990, 14),
woosh.Token(woosh.NAME, 'cls', 990, 15, 990, 18),
woosh.Token(woosh.OP, '.', 990, 18, 990, 19),
woosh.Token(woosh.NAME, '_create_header', 990, 19, 990, 33),
woosh.Token(woosh.OP, '(', 990, 33, 990, 34),
woosh.Token(woosh.NAME, 'info', 990, 34, 990, 38),
woosh.Token(woosh.OP, ',', 990, 38, 990, 39),
woosh.Token(woosh.NAME, 'USTAR_FORMAT', 990, 40, 990, 52),
woosh.Token(woosh.OP, ',', 990, 52, 990, 53),
woosh.Token(woosh.NAME, 'encoding', 990, 54, 990, 62),
woosh.Token(woosh.OP, ',', 990, 62, 990, 63),
woosh.Token(woosh.NAME, 'errors', 990, 64, 990, 70),
woosh.Token(woosh.OP, ')', 990, 70, 990, 71),
woosh.Token(woosh.OP, '+', 990, 72, 990, 73),
woosh.Token(woosh.NAME, 'cls', 991, 16, 991, 19),
woosh.Token(woosh.OP, '.', 991, 19, 991, 20),
woosh.Token(woosh.NAME, '_create_payload', 991, 20, 991, 35),
woosh.Token(woosh.OP, '(', 991, 35, 991, 36),
woosh.Token(woosh.NAME, 'name', 991, 36, 991, 40),
woosh.Token(woosh.OP, ')', 991, 40, 991, 41),
woosh.Token(woosh.NEWLINE, '\r\n', 991, 41, 992, 0),
woosh.Token(woosh.DEDENT, ' ', 993, 0, 993, 4),
woosh.Token(woosh.OP, '@', 993, 4, 993, 5),
woosh.Token(woosh.NAME, 'classmethod', 993, 5, 993, 16),
woosh.Token(woosh.NEWLINE, '\r\n', 993, 16, 994, 0),
woosh.Token(woosh.NAME, 'def', 994, 4, 994, 7),
woosh.Token(woosh.NAME, '_create_pax_generic_header', 994, 8, 994, 34),
woosh.Token(woosh.OP, '(', 994, 34, 994, 35),
woosh.Token(woosh.NAME, 'cls', 994, 35, 994, 38),
woosh.Token(woosh.OP, ',', 994, 38, 994, 39),
woosh.Token(woosh.NAME, 'pax_headers', 994, 40, 994, 51),
woosh.Token(woosh.OP, ',', 994, 51, 994, 52),
woosh.Token(woosh.NAME, 'type', 994, 53, 994, 57),
woosh.Token(woosh.OP, ',', 994, 57, 994, 58),
woosh.Token(woosh.NAME, 'encoding', 994, 59, 994, 67),
woosh.Token(woosh.OP, ')', 994, 67, 994, 68),
woosh.Token(woosh.OP, ':', 994, 68, 994, 69),
woosh.Token(woosh.NEWLINE, '\r\n', 994, 69, 995, 0),
woosh.Token(woosh.INDENT, ' ', 995, 0, 995, 8),
woosh.Token(woosh.STRING, '"""Return a POSIX.1-2008 extended or global header sequence\r\n that contains a list of keyword, value pairs. The values\r\n must be strings.\r\n """', 995, 8, 998, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 998, 11, 999, 0),
woosh.Token(woosh.COMMENT, '# Check if one of the fields contains surrogate characters and thereby', 999, 8, 999, 78),
woosh.Token(woosh.COMMENT, '# forces hdrcharset=BINARY, see _proc_pax() for more information.', 1000, 8, 1000, 73),
woosh.Token(woosh.NAME, 'binary', 1001, 8, 1001, 14),
woosh.Token(woosh.OP, '=', 1001, 15, 1001, 16),
woosh.Token(woosh.NAME, 'False', 1001, 17, 1001, 22),
woosh.Token(woosh.NEWLINE, '\r\n', 1001, 22, 1002, 0),
woosh.Token(woosh.NAME, 'for', 1002, 8, 1002, 11),
woosh.Token(woosh.NAME, 'keyword', 1002, 12, 1002, 19),
woosh.Token(woosh.OP, ',', 1002, 19, 1002, 20),
woosh.Token(woosh.NAME, 'value', 1002, 21, 1002, 26),
woosh.Token(woosh.NAME, 'in', 1002, 27, 1002, 29),
woosh.Token(woosh.NAME, 'pax_headers', 1002, 30, 1002, 41),
woosh.Token(woosh.OP, '.', 1002, 41, 1002, 42),
woosh.Token(woosh.NAME, 'items', 1002, 42, 1002, 47),
woosh.Token(woosh.OP, '(', 1002, 47, 1002, 48),
woosh.Token(woosh.OP, ')', 1002, 48, 1002, 49),
woosh.Token(woosh.OP, ':', 1002, 49, 1002, 50),
woosh.Token(woosh.NEWLINE, '\r\n', 1002, 50, 1003, 0),
woosh.Token(woosh.INDENT, ' ', 1003, 0, 1003, 12),
woosh.Token(woosh.NAME, 'try', 1003, 12, 1003, 15),
woosh.Token(woosh.OP, ':', 1003, 15, 1003, 16),
woosh.Token(woosh.NEWLINE, '\r\n', 1003, 16, 1004, 0),
woosh.Token(woosh.INDENT, ' ', 1004, 0, 1004, 16),
woosh.Token(woosh.NAME, 'value', 1004, 16, 1004, 21),
woosh.Token(woosh.OP, '.', 1004, 21, 1004, 22),
woosh.Token(woosh.NAME, 'encode', 1004, 22, 1004, 28),
woosh.Token(woosh.OP, '(', 1004, 28, 1004, 29),
woosh.Token(woosh.STRING, '"utf-8"', 1004, 29, 1004, 36),
woosh.Token(woosh.OP, ',', 1004, 36, 1004, 37),
woosh.Token(woosh.STRING, '"strict"', 1004, 38, 1004, 46),
woosh.Token(woosh.OP, ')', 1004, 46, 1004, 47),
woosh.Token(woosh.NEWLINE, '\r\n', 1004, 47, 1005, 0),
woosh.Token(woosh.DEDENT, ' ', 1005, 0, 1005, 12),
woosh.Token(woosh.NAME, 'except', 1005, 12, 1005, 18),
woosh.Token(woosh.NAME, 'UnicodeEncodeError', 1005, 19, 1005, 37),
woosh.Token(woosh.OP, ':', 1005, 37, 1005, 38),
woosh.Token(woosh.NEWLINE, '\r\n', 1005, 38, 1006, 0),
woosh.Token(woosh.INDENT, ' ', 1006, 0, 1006, 16),
woosh.Token(woosh.NAME, 'binary', 1006, 16, 1006, 22),
woosh.Token(woosh.OP, '=', 1006, 23, 1006, 24),
woosh.Token(woosh.NAME, 'True', 1006, 25, 1006, 29),
woosh.Token(woosh.NEWLINE, '\r\n', 1006, 29, 1007, 0),
woosh.Token(woosh.NAME, 'break', 1007, 16, 1007, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 1007, 21, 1008, 0),
woosh.Token(woosh.DEDENT, ' ', 1009, 0, 1009, 8),
woosh.Token(woosh.DEDENT, '', 1009, 8, 1009, 8),
woosh.Token(woosh.NAME, 'records', 1009, 8, 1009, 15),
woosh.Token(woosh.OP, '=', 1009, 16, 1009, 17),
woosh.Token(woosh.STRING, 'b""', 1009, 18, 1009, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 1009, 21, 1010, 0),
woosh.Token(woosh.NAME, 'if', 1010, 8, 1010, 10),
woosh.Token(woosh.NAME, 'binary', 1010, 11, 1010, 17),
woosh.Token(woosh.OP, ':', 1010, 17, 1010, 18),
woosh.Token(woosh.NEWLINE, '\r\n', 1010, 18, 1011, 0),
woosh.Token(woosh.COMMENT, '# Put the hdrcharset field at the beginning of the header.', 1011, 12, 1011, 70),
woosh.Token(woosh.INDENT, ' ', 1012, 0, 1012, 12),
woosh.Token(woosh.NAME, 'records', 1012, 12, 1012, 19),
woosh.Token(woosh.OP, '+=', 1012, 20, 1012, 22),
woosh.Token(woosh.STRING, 'b"21 hdrcharset=BINARY\\n"', 1012, 23, 1012, 48),
woosh.Token(woosh.NEWLINE, '\r\n', 1012, 48, 1013, 0),
woosh.Token(woosh.DEDENT, ' ', 1014, 0, 1014, 8),
woosh.Token(woosh.NAME, 'for', 1014, 8, 1014, 11),
woosh.Token(woosh.NAME, 'keyword', 1014, 12, 1014, 19),
woosh.Token(woosh.OP, ',', 1014, 19, 1014, 20),
woosh.Token(woosh.NAME, 'value', 1014, 21, 1014, 26),
woosh.Token(woosh.NAME, 'in', 1014, 27, 1014, 29),
woosh.Token(woosh.NAME, 'pax_headers', 1014, 30, 1014, 41),
woosh.Token(woosh.OP, '.', 1014, 41, 1014, 42),
woosh.Token(woosh.NAME, 'items', 1014, 42, 1014, 47),
woosh.Token(woosh.OP, '(', 1014, 47, 1014, 48),
woosh.Token(woosh.OP, ')', 1014, 48, 1014, 49),
woosh.Token(woosh.OP, ':', 1014, 49, 1014, 50),
woosh.Token(woosh.NEWLINE, '\r\n', 1014, 50, 1015, 0),
woosh.Token(woosh.INDENT, ' ', 1015, 0, 1015, 12),
woosh.Token(woosh.NAME, 'keyword', 1015, 12, 1015, 19),
woosh.Token(woosh.OP, '=', 1015, 20, 1015, 21),
woosh.Token(woosh.NAME, 'keyword', 1015, 22, 1015, 29),
woosh.Token(woosh.OP, '.', 1015, 29, 1015, 30),
woosh.Token(woosh.NAME, 'encode', 1015, 30, 1015, 36),
woosh.Token(woosh.OP, '(', 1015, 36, 1015, 37),
woosh.Token(woosh.STRING, '"utf-8"', 1015, 37, 1015, 44),
woosh.Token(woosh.OP, ')', 1015, 44, 1015, 45),
woosh.Token(woosh.NEWLINE, '\r\n', 1015, 45, 1016, 0),
woosh.Token(woosh.NAME, 'if', 1016, 12, 1016, 14),
woosh.Token(woosh.NAME, 'binary', 1016, 15, 1016, 21),
woosh.Token(woosh.OP, ':', 1016, 21, 1016, 22),
woosh.Token(woosh.NEWLINE, '\r\n', 1016, 22, 1017, 0),
woosh.Token(woosh.COMMENT, "# Try to restore the original byte representation of `value'.", 1017, 16, 1017, 77),
woosh.Token(woosh.COMMENT, '# Needless to say, that the encoding must match the string.', 1018, 16, 1018, 75),
woosh.Token(woosh.INDENT, ' ', 1019, 0, 1019, 16),
woosh.Token(woosh.NAME, 'value', 1019, 16, 1019, 21),
woosh.Token(woosh.OP, '=', 1019, 22, 1019, 23),
woosh.Token(woosh.NAME, 'value', 1019, 24, 1019, 29),
woosh.Token(woosh.OP, '.', 1019, 29, 1019, 30),
woosh.Token(woosh.NAME, 'encode', 1019, 30, 1019, 36),
woosh.Token(woosh.OP, '(', 1019, 36, 1019, 37),
woosh.Token(woosh.NAME, 'encoding', 1019, 37, 1019, 45),
woosh.Token(woosh.OP, ',', 1019, 45, 1019, 46),
woosh.Token(woosh.STRING, '"surrogateescape"', 1019, 47, 1019, 64),
woosh.Token(woosh.OP, ')', 1019, 64, 1019, 65),
woosh.Token(woosh.NEWLINE, '\r\n', 1019, 65, 1020, 0),
woosh.Token(woosh.DEDENT, ' ', 1020, 0, 1020, 12),
woosh.Token(woosh.NAME, 'else', 1020, 12, 1020, 16),
woosh.Token(woosh.OP, ':', 1020, 16, 1020, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 1020, 17, 1021, 0),
woosh.Token(woosh.INDENT, ' ', 1021, 0, 1021, 16),
woosh.Token(woosh.NAME, 'value', 1021, 16, 1021, 21),
woosh.Token(woosh.OP, '=', 1021, 22, 1021, 23),
woosh.Token(woosh.NAME, 'value', 1021, 24, 1021, 29),
woosh.Token(woosh.OP, '.', 1021, 29, 1021, 30),
woosh.Token(woosh.NAME, 'encode', 1021, 30, 1021, 36),
woosh.Token(woosh.OP, '(', 1021, 36, 1021, 37),
woosh.Token(woosh.STRING, '"utf-8"', 1021, 37, 1021, 44),
woosh.Token(woosh.OP, ')', 1021, 44, 1021, 45),
woosh.Token(woosh.NEWLINE, '\r\n', 1021, 45, 1022, 0),
woosh.Token(woosh.DEDENT, ' ', 1023, 0, 1023, 12),
woosh.Token(woosh.NAME, 'l', 1023, 12, 1023, 13),
woosh.Token(woosh.OP, '=', 1023, 14, 1023, 15),
woosh.Token(woosh.NAME, 'len', 1023, 16, 1023, 19),
woosh.Token(woosh.OP, '(', 1023, 19, 1023, 20),
woosh.Token(woosh.NAME, 'keyword', 1023, 20, 1023, 27),
woosh.Token(woosh.OP, ')', 1023, 27, 1023, 28),
woosh.Token(woosh.OP, '+', 1023, 29, 1023, 30),
woosh.Token(woosh.NAME, 'len', 1023, 31, 1023, 34),
woosh.Token(woosh.OP, '(', 1023, 34, 1023, 35),
woosh.Token(woosh.NAME, 'value', 1023, 35, 1023, 40),
woosh.Token(woosh.OP, ')', 1023, 40, 1023, 41),
woosh.Token(woosh.OP, '+', 1023, 42, 1023, 43),
woosh.Token(woosh.NUMBER, '3', 1023, 44, 1023, 45),
woosh.Token(woosh.COMMENT, "# ' ' + '=' + '\\n'", 1023, 48, 1023, 66),
woosh.Token(woosh.NEWLINE, '\r\n', 1023, 66, 1024, 0),
woosh.Token(woosh.NAME, 'n', 1024, 12, 1024, 13),
woosh.Token(woosh.OP, '=', 1024, 14, 1024, 15),
woosh.Token(woosh.NAME, 'p', 1024, 16, 1024, 17),
woosh.Token(woosh.OP, '=', 1024, 18, 1024, 19),
woosh.Token(woosh.NUMBER, '0', 1024, 20, 1024, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 1024, 21, 1025, 0),
woosh.Token(woosh.NAME, 'while', 1025, 12, 1025, 17),
woosh.Token(woosh.NAME, 'True', 1025, 18, 1025, 22),
woosh.Token(woosh.OP, ':', 1025, 22, 1025, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 1025, 23, 1026, 0),
woosh.Token(woosh.INDENT, ' ', 1026, 0, 1026, 16),
woosh.Token(woosh.NAME, 'n', 1026, 16, 1026, 17),
woosh.Token(woosh.OP, '=', 1026, 18, 1026, 19),
woosh.Token(woosh.NAME, 'l', 1026, 20, 1026, 21),
woosh.Token(woosh.OP, '+', 1026, 22, 1026, 23),
woosh.Token(woosh.NAME, 'len', 1026, 24, 1026, 27),
woosh.Token(woosh.OP, '(', 1026, 27, 1026, 28),
woosh.Token(woosh.NAME, 'str', 1026, 28, 1026, 31),
woosh.Token(woosh.OP, '(', 1026, 31, 1026, 32),
woosh.Token(woosh.NAME, 'p', 1026, 32, 1026, 33),
woosh.Token(woosh.OP, ')', 1026, 33, 1026, 34),
woosh.Token(woosh.OP, ')', 1026, 34, 1026, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 1026, 35, 1027, 0),
woosh.Token(woosh.NAME, 'if', 1027, 16, 1027, 18),
woosh.Token(woosh.NAME, 'n', 1027, 19, 1027, 20),
woosh.Token(woosh.OP, '==', 1027, 21, 1027, 23),
woosh.Token(woosh.NAME, 'p', 1027, 24, 1027, 25),
woosh.Token(woosh.OP, ':', 1027, 25, 1027, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 1027, 26, 1028, 0),
woosh.Token(woosh.INDENT, ' ', 1028, 0, 1028, 20),
woosh.Token(woosh.NAME, 'break', 1028, 20, 1028, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 1028, 25, 1029, 0),
woosh.Token(woosh.DEDENT, ' ', 1029, 0, 1029, 16),
woosh.Token(woosh.NAME, 'p', 1029, 16, 1029, 17),
woosh.Token(woosh.OP, '=', 1029, 18, 1029, 19),
woosh.Token(woosh.NAME, 'n', 1029, 20, 1029, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 1029, 21, 1030, 0),
woosh.Token(woosh.DEDENT, ' ', 1030, 0, 1030, 12),
woosh.Token(woosh.NAME, 'records', 1030, 12, 1030, 19),
woosh.Token(woosh.OP, '+=', 1030, 20, 1030, 22),
woosh.Token(woosh.NAME, 'bytes', 1030, 23, 1030, 28),
woosh.Token(woosh.OP, '(', 1030, 28, 1030, 29),
woosh.Token(woosh.NAME, 'str', 1030, 29, 1030, 32),
woosh.Token(woosh.OP, '(', 1030, 32, 1030, 33),
woosh.Token(woosh.NAME, 'p', 1030, 33, 1030, 34),
woosh.Token(woosh.OP, ')', 1030, 34, 1030, 35),
woosh.Token(woosh.OP, ',', 1030, 35, 1030, 36),
woosh.Token(woosh.STRING, '"ascii"', 1030, 37, 1030, 44),
woosh.Token(woosh.OP, ')', 1030, 44, 1030, 45),
woosh.Token(woosh.OP, '+', 1030, 46, 1030, 47),
woosh.Token(woosh.STRING, 'b" "', 1030, 48, 1030, 52),
woosh.Token(woosh.OP, '+', 1030, 53, 1030, 54),
woosh.Token(woosh.NAME, 'keyword', 1030, 55, 1030, 62),
woosh.Token(woosh.OP, '+', 1030, 63, 1030, 64),
woosh.Token(woosh.STRING, 'b"="', 1030, 65, 1030, 69),
woosh.Token(woosh.OP, '+', 1030, 70, 1030, 71),
woosh.Token(woosh.NAME, 'value', 1030, 72, 1030, 77),
woosh.Token(woosh.OP, '+', 1030, 78, 1030, 79),
woosh.Token(woosh.STRING, 'b"\\n"', 1030, 80, 1030, 85),
woosh.Token(woosh.NEWLINE, '\r\n', 1030, 85, 1031, 0),
woosh.Token(woosh.COMMENT, '# We use a hardcoded "././@PaxHeader" name like star does', 1032, 8, 1032, 65),
woosh.Token(woosh.COMMENT, '# instead of the one that POSIX recommends.', 1033, 8, 1033, 51),
woosh.Token(woosh.DEDENT, ' ', 1034, 0, 1034, 8),
woosh.Token(woosh.NAME, 'info', 1034, 8, 1034, 12),
woosh.Token(woosh.OP, '=', 1034, 13, 1034, 14),
woosh.Token(woosh.OP, '{', 1034, 15, 1034, 16),
woosh.Token(woosh.OP, '}', 1034, 16, 1034, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 1034, 17, 1035, 0),
woosh.Token(woosh.NAME, 'info', 1035, 8, 1035, 12),
woosh.Token(woosh.OP, '[', 1035, 12, 1035, 13),
woosh.Token(woosh.STRING, '"name"', 1035, 13, 1035, 19),
woosh.Token(woosh.OP, ']', 1035, 19, 1035, 20),
woosh.Token(woosh.OP, '=', 1035, 21, 1035, 22),
woosh.Token(woosh.STRING, '"././@PaxHeader"', 1035, 23, 1035, 39),
woosh.Token(woosh.NEWLINE, '\r\n', 1035, 39, 1036, 0),
woosh.Token(woosh.NAME, 'info', 1036, 8, 1036, 12),
woosh.Token(woosh.OP, '[', 1036, 12, 1036, 13),
woosh.Token(woosh.STRING, '"type"', 1036, 13, 1036, 19),
woosh.Token(woosh.OP, ']', 1036, 19, 1036, 20),
woosh.Token(woosh.OP, '=', 1036, 21, 1036, 22),
woosh.Token(woosh.NAME, 'type', 1036, 23, 1036, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 1036, 27, 1037, 0),
woosh.Token(woosh.NAME, 'info', 1037, 8, 1037, 12),
woosh.Token(woosh.OP, '[', 1037, 12, 1037, 13),
woosh.Token(woosh.STRING, '"size"', 1037, 13, 1037, 19),
woosh.Token(woosh.OP, ']', 1037, 19, 1037, 20),
woosh.Token(woosh.OP, '=', 1037, 21, 1037, 22),
woosh.Token(woosh.NAME, 'len', 1037, 23, 1037, 26),
woosh.Token(woosh.OP, '(', 1037, 26, 1037, 27),
woosh.Token(woosh.NAME, 'records', 1037, 27, 1037, 34),
woosh.Token(woosh.OP, ')', 1037, 34, 1037, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 1037, 35, 1038, 0),
woosh.Token(woosh.NAME, 'info', 1038, 8, 1038, 12),
woosh.Token(woosh.OP, '[', 1038, 12, 1038, 13),
woosh.Token(woosh.STRING, '"magic"', 1038, 13, 1038, 20),
woosh.Token(woosh.OP, ']', 1038, 20, 1038, 21),
woosh.Token(woosh.OP, '=', 1038, 22, 1038, 23),
woosh.Token(woosh.NAME, 'POSIX_MAGIC', 1038, 24, 1038, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 1038, 35, 1039, 0),
woosh.Token(woosh.COMMENT, '# Create pax header + record blocks.', 1040, 8, 1040, 44),
woosh.Token(woosh.NAME, 'return', 1041, 8, 1041, 14),
woosh.Token(woosh.NAME, 'cls', 1041, 15, 1041, 18),
woosh.Token(woosh.OP, '.', 1041, 18, 1041, 19),
woosh.Token(woosh.NAME, '_create_header', 1041, 19, 1041, 33),
woosh.Token(woosh.OP, '(', 1041, 33, 1041, 34),
woosh.Token(woosh.NAME, 'info', 1041, 34, 1041, 38),
woosh.Token(woosh.OP, ',', 1041, 38, 1041, 39),
woosh.Token(woosh.NAME, 'USTAR_FORMAT', 1041, 40, 1041, 52),
woosh.Token(woosh.OP, ',', 1041, 52, 1041, 53),
woosh.Token(woosh.STRING, '"ascii"', 1041, 54, 1041, 61),
woosh.Token(woosh.OP, ',', 1041, 61, 1041, 62),
woosh.Token(woosh.STRING, '"replace"', 1041, 63, 1041, 72),
woosh.Token(woosh.OP, ')', 1041, 72, 1041, 73),
woosh.Token(woosh.OP, '+', 1041, 74, 1041, 75),
woosh.Token(woosh.NAME, 'cls', 1042, 16, 1042, 19),
woosh.Token(woosh.OP, '.', 1042, 19, 1042, 20),
woosh.Token(woosh.NAME, '_create_payload', 1042, 20, 1042, 35),
woosh.Token(woosh.OP, '(', 1042, 35, 1042, 36),
woosh.Token(woosh.NAME, 'records', 1042, 36, 1042, 43),
woosh.Token(woosh.OP, ')', 1042, 43, 1042, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 1042, 44, 1043, 0),
woosh.Token(woosh.DEDENT, ' ', 1044, 0, 1044, 4),
woosh.Token(woosh.OP, '@', 1044, 4, 1044, 5),
woosh.Token(woosh.NAME, 'classmethod', 1044, 5, 1044, 16),
woosh.Token(woosh.NEWLINE, '\r\n', 1044, 16, 1045, 0),
woosh.Token(woosh.NAME, 'def', 1045, 4, 1045, 7),
woosh.Token(woosh.NAME, 'frombuf', 1045, 8, 1045, 15),
woosh.Token(woosh.OP, '(', 1045, 15, 1045, 16),
woosh.Token(woosh.NAME, 'cls', 1045, 16, 1045, 19),
woosh.Token(woosh.OP, ',', 1045, 19, 1045, 20),
woosh.Token(woosh.NAME, 'buf', 1045, 21, 1045, 24),
woosh.Token(woosh.OP, ',', 1045, 24, 1045, 25),
woosh.Token(woosh.NAME, 'encoding', 1045, 26, 1045, 34),
woosh.Token(woosh.OP, ',', 1045, 34, 1045, 35),
woosh.Token(woosh.NAME, 'errors', 1045, 36, 1045, 42),
woosh.Token(woosh.OP, ')', 1045, 42, 1045, 43),
woosh.Token(woosh.OP, ':', 1045, 43, 1045, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 1045, 44, 1046, 0),
woosh.Token(woosh.INDENT, ' ', 1046, 0, 1046, 8),
woosh.Token(woosh.STRING, '"""Construct a TarInfo object from a 512 byte bytes object.\r\n """', 1046, 8, 1047, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 1047, 11, 1048, 0),
woosh.Token(woosh.NAME, 'if', 1048, 8, 1048, 10),
woosh.Token(woosh.NAME, 'len', 1048, 11, 1048, 14),
woosh.Token(woosh.OP, '(', 1048, 14, 1048, 15),
woosh.Token(woosh.NAME, 'buf', 1048, 15, 1048, 18),
woosh.Token(woosh.OP, ')', 1048, 18, 1048, 19),
woosh.Token(woosh.OP, '==', 1048, 20, 1048, 22),
woosh.Token(woosh.NUMBER, '0', 1048, 23, 1048, 24),
woosh.Token(woosh.OP, ':', 1048, 24, 1048, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 1048, 25, 1049, 0),
woosh.Token(woosh.INDENT, ' ', 1049, 0, 1049, 12),
woosh.Token(woosh.NAME, 'raise', 1049, 12, 1049, 17),
woosh.Token(woosh.NAME, 'EmptyHeaderError', 1049, 18, 1049, 34),
woosh.Token(woosh.OP, '(', 1049, 34, 1049, 35),
woosh.Token(woosh.STRING, '"empty header"', 1049, 35, 1049, 49),
woosh.Token(woosh.OP, ')', 1049, 49, 1049, 50),
woosh.Token(woosh.NEWLINE, '\r\n', 1049, 50, 1050, 0),
woosh.Token(woosh.DEDENT, ' ', 1050, 0, 1050, 8),
woosh.Token(woosh.NAME, 'if', 1050, 8, 1050, 10),
woosh.Token(woosh.NAME, 'len', 1050, 11, 1050, 14),
woosh.Token(woosh.OP, '(', 1050, 14, 1050, 15),
woosh.Token(woosh.NAME, 'buf', 1050, 15, 1050, 18),
woosh.Token(woosh.OP, ')', 1050, 18, 1050, 19),
woosh.Token(woosh.OP, '!=', 1050, 20, 1050, 22),
woosh.Token(woosh.NAME, 'BLOCKSIZE', 1050, 23, 1050, 32),
woosh.Token(woosh.OP, ':', 1050, 32, 1050, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 1050, 33, 1051, 0),
woosh.Token(woosh.INDENT, ' ', 1051, 0, 1051, 12),
woosh.Token(woosh.NAME, 'raise', 1051, 12, 1051, 17),
woosh.Token(woosh.NAME, 'TruncatedHeaderError', 1051, 18, 1051, 38),
woosh.Token(woosh.OP, '(', 1051, 38, 1051, 39),
woosh.Token(woosh.STRING, '"truncated header"', 1051, 39, 1051, 57),
woosh.Token(woosh.OP, ')', 1051, 57, 1051, 58),
woosh.Token(woosh.NEWLINE, '\r\n', 1051, 58, 1052, 0),
woosh.Token(woosh.DEDENT, ' ', 1052, 0, 1052, 8),
woosh.Token(woosh.NAME, 'if', 1052, 8, 1052, 10),
woosh.Token(woosh.NAME, 'buf', 1052, 11, 1052, 14),
woosh.Token(woosh.OP, '.', 1052, 14, 1052, 15),
woosh.Token(woosh.NAME, 'count', 1052, 15, 1052, 20),
woosh.Token(woosh.OP, '(', 1052, 20, 1052, 21),
woosh.Token(woosh.NAME, 'NUL', 1052, 21, 1052, 24),
woosh.Token(woosh.OP, ')', 1052, 24, 1052, 25),
woosh.Token(woosh.OP, '==', 1052, 26, 1052, 28),
woosh.Token(woosh.NAME, 'BLOCKSIZE', 1052, 29, 1052, 38),
woosh.Token(woosh.OP, ':', 1052, 38, 1052, 39),
woosh.Token(woosh.NEWLINE, '\r\n', 1052, 39, 1053, 0),
woosh.Token(woosh.INDENT, ' ', 1053, 0, 1053, 12),
woosh.Token(woosh.NAME, 'raise', 1053, 12, 1053, 17),
woosh.Token(woosh.NAME, 'EOFHeaderError', 1053, 18, 1053, 32),
woosh.Token(woosh.OP, '(', 1053, 32, 1053, 33),
woosh.Token(woosh.STRING, '"end of file header"', 1053, 33, 1053, 53),
woosh.Token(woosh.OP, ')', 1053, 53, 1053, 54),
woosh.Token(woosh.NEWLINE, '\r\n', 1053, 54, 1054, 0),
woosh.Token(woosh.DEDENT, ' ', 1055, 0, 1055, 8),
woosh.Token(woosh.NAME, 'chksum', 1055, 8, 1055, 14),
woosh.Token(woosh.OP, '=', 1055, 15, 1055, 16),
woosh.Token(woosh.NAME, 'nti', 1055, 17, 1055, 20),
woosh.Token(woosh.OP, '(', 1055, 20, 1055, 21),
woosh.Token(woosh.NAME, 'buf', 1055, 21, 1055, 24),
woosh.Token(woosh.OP, '[', 1055, 24, 1055, 25),
woosh.Token(woosh.NUMBER, '148', 1055, 25, 1055, 28),
woosh.Token(woosh.OP, ':', 1055, 28, 1055, 29),
woosh.Token(woosh.NUMBER, '156', 1055, 29, 1055, 32),
woosh.Token(woosh.OP, ']', 1055, 32, 1055, 33),
woosh.Token(woosh.OP, ')', 1055, 33, 1055, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 1055, 34, 1056, 0),
woosh.Token(woosh.NAME, 'if', 1056, 8, 1056, 10),
woosh.Token(woosh.NAME, 'chksum', 1056, 11, 1056, 17),
woosh.Token(woosh.NAME, 'not', 1056, 18, 1056, 21),
woosh.Token(woosh.NAME, 'in', 1056, 22, 1056, 24),
woosh.Token(woosh.NAME, 'calc_chksums', 1056, 25, 1056, 37),
woosh.Token(woosh.OP, '(', 1056, 37, 1056, 38),
woosh.Token(woosh.NAME, 'buf', 1056, 38, 1056, 41),
woosh.Token(woosh.OP, ')', 1056, 41, 1056, 42),
woosh.Token(woosh.OP, ':', 1056, 42, 1056, 43),
woosh.Token(woosh.NEWLINE, '\r\n', 1056, 43, 1057, 0),
woosh.Token(woosh.INDENT, ' ', 1057, 0, 1057, 12),
woosh.Token(woosh.NAME, 'raise', 1057, 12, 1057, 17),
woosh.Token(woosh.NAME, 'InvalidHeaderError', 1057, 18, 1057, 36),
woosh.Token(woosh.OP, '(', 1057, 36, 1057, 37),
woosh.Token(woosh.STRING, '"bad checksum"', 1057, 37, 1057, 51),
woosh.Token(woosh.OP, ')', 1057, 51, 1057, 52),
woosh.Token(woosh.NEWLINE, '\r\n', 1057, 52, 1058, 0),
woosh.Token(woosh.DEDENT, ' ', 1059, 0, 1059, 8),
woosh.Token(woosh.NAME, 'obj', 1059, 8, 1059, 11),
woosh.Token(woosh.OP, '=', 1059, 12, 1059, 13),
woosh.Token(woosh.NAME, 'cls', 1059, 14, 1059, 17),
woosh.Token(woosh.OP, '(', 1059, 17, 1059, 18),
woosh.Token(woosh.OP, ')', 1059, 18, 1059, 19),
woosh.Token(woosh.NEWLINE, '\r\n', 1059, 19, 1060, 0),
woosh.Token(woosh.NAME, 'obj', 1060, 8, 1060, 11),
woosh.Token(woosh.OP, '.', 1060, 11, 1060, 12),
woosh.Token(woosh.NAME, 'name', 1060, 12, 1060, 16),
woosh.Token(woosh.OP, '=', 1060, 17, 1060, 18),
woosh.Token(woosh.NAME, 'nts', 1060, 19, 1060, 22),
woosh.Token(woosh.OP, '(', 1060, 22, 1060, 23),
woosh.Token(woosh.NAME, 'buf', 1060, 23, 1060, 26),
woosh.Token(woosh.OP, '[', 1060, 26, 1060, 27),
woosh.Token(woosh.NUMBER, '0', 1060, 27, 1060, 28),
woosh.Token(woosh.OP, ':', 1060, 28, 1060, 29),
woosh.Token(woosh.NUMBER, '100', 1060, 29, 1060, 32),
woosh.Token(woosh.OP, ']', 1060, 32, 1060, 33),
woosh.Token(woosh.OP, ',', 1060, 33, 1060, 34),
woosh.Token(woosh.NAME, 'encoding', 1060, 35, 1060, 43),
woosh.Token(woosh.OP, ',', 1060, 43, 1060, 44),
woosh.Token(woosh.NAME, 'errors', 1060, 45, 1060, 51),
woosh.Token(woosh.OP, ')', 1060, 51, 1060, 52),
woosh.Token(woosh.NEWLINE, '\r\n', 1060, 52, 1061, 0),
woosh.Token(woosh.NAME, 'obj', 1061, 8, 1061, 11),
woosh.Token(woosh.OP, '.', 1061, 11, 1061, 12),
woosh.Token(woosh.NAME, 'mode', 1061, 12, 1061, 16),
woosh.Token(woosh.OP, '=', 1061, 17, 1061, 18),
woosh.Token(woosh.NAME, 'nti', 1061, 19, 1061, 22),
woosh.Token(woosh.OP, '(', 1061, 22, 1061, 23),
woosh.Token(woosh.NAME, 'buf', 1061, 23, 1061, 26),
woosh.Token(woosh.OP, '[', 1061, 26, 1061, 27),
woosh.Token(woosh.NUMBER, '100', 1061, 27, 1061, 30),
woosh.Token(woosh.OP, ':', 1061, 30, 1061, 31),
woosh.Token(woosh.NUMBER, '108', 1061, 31, 1061, 34),
woosh.Token(woosh.OP, ']', 1061, 34, 1061, 35),
woosh.Token(woosh.OP, ')', 1061, 35, 1061, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 1061, 36, 1062, 0),
woosh.Token(woosh.NAME, 'obj', 1062, 8, 1062, 11),
woosh.Token(woosh.OP, '.', 1062, 11, 1062, 12),
woosh.Token(woosh.NAME, 'uid', 1062, 12, 1062, 15),
woosh.Token(woosh.OP, '=', 1062, 16, 1062, 17),
woosh.Token(woosh.NAME, 'nti', 1062, 18, 1062, 21),
woosh.Token(woosh.OP, '(', 1062, 21, 1062, 22),
woosh.Token(woosh.NAME, 'buf', 1062, 22, 1062, 25),
woosh.Token(woosh.OP, '[', 1062, 25, 1062, 26),
woosh.Token(woosh.NUMBER, '108', 1062, 26, 1062, 29),
woosh.Token(woosh.OP, ':', 1062, 29, 1062, 30),
woosh.Token(woosh.NUMBER, '116', 1062, 30, 1062, 33),
woosh.Token(woosh.OP, ']', 1062, 33, 1062, 34),
woosh.Token(woosh.OP, ')', 1062, 34, 1062, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 1062, 35, 1063, 0),
woosh.Token(woosh.NAME, 'obj', 1063, 8, 1063, 11),
woosh.Token(woosh.OP, '.', 1063, 11, 1063, 12),
woosh.Token(woosh.NAME, 'gid', 1063, 12, 1063, 15),
woosh.Token(woosh.OP, '=', 1063, 16, 1063, 17),
woosh.Token(woosh.NAME, 'nti', 1063, 18, 1063, 21),
woosh.Token(woosh.OP, '(', 1063, 21, 1063, 22),
woosh.Token(woosh.NAME, 'buf', 1063, 22, 1063, 25),
woosh.Token(woosh.OP, '[', 1063, 25, 1063, 26),
woosh.Token(woosh.NUMBER, '116', 1063, 26, 1063, 29),
woosh.Token(woosh.OP, ':', 1063, 29, 1063, 30),
woosh.Token(woosh.NUMBER, '124', 1063, 30, 1063, 33),
woosh.Token(woosh.OP, ']', 1063, 33, 1063, 34),
woosh.Token(woosh.OP, ')', 1063, 34, 1063, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 1063, 35, 1064, 0),
woosh.Token(woosh.NAME, 'obj', 1064, 8, 1064, 11),
woosh.Token(woosh.OP, '.', 1064, 11, 1064, 12),
woosh.Token(woosh.NAME, 'size', 1064, 12, 1064, 16),
woosh.Token(woosh.OP, '=', 1064, 17, 1064, 18),
woosh.Token(woosh.NAME, 'nti', 1064, 19, 1064, 22),
woosh.Token(woosh.OP, '(', 1064, 22, 1064, 23),
woosh.Token(woosh.NAME, 'buf', 1064, 23, 1064, 26),
woosh.Token(woosh.OP, '[', 1064, 26, 1064, 27),
woosh.Token(woosh.NUMBER, '124', 1064, 27, 1064, 30),
woosh.Token(woosh.OP, ':', 1064, 30, 1064, 31),
woosh.Token(woosh.NUMBER, '136', 1064, 31, 1064, 34),
woosh.Token(woosh.OP, ']', 1064, 34, 1064, 35),
woosh.Token(woosh.OP, ')', 1064, 35, 1064, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 1064, 36, 1065, 0),
woosh.Token(woosh.NAME, 'obj', 1065, 8, 1065, 11),
woosh.Token(woosh.OP, '.', 1065, 11, 1065, 12),
woosh.Token(woosh.NAME, 'mtime', 1065, 12, 1065, 17),
woosh.Token(woosh.OP, '=', 1065, 18, 1065, 19),
woosh.Token(woosh.NAME, 'nti', 1065, 20, 1065, 23),
woosh.Token(woosh.OP, '(', 1065, 23, 1065, 24),
woosh.Token(woosh.NAME, 'buf', 1065, 24, 1065, 27),
woosh.Token(woosh.OP, '[', 1065, 27, 1065, 28),
woosh.Token(woosh.NUMBER, '136', 1065, 28, 1065, 31),
woosh.Token(woosh.OP, ':', 1065, 31, 1065, 32),
woosh.Token(woosh.NUMBER, '148', 1065, 32, 1065, 35),
woosh.Token(woosh.OP, ']', 1065, 35, 1065, 36),
woosh.Token(woosh.OP, ')', 1065, 36, 1065, 37),
woosh.Token(woosh.NEWLINE, '\r\n', 1065, 37, 1066, 0),
woosh.Token(woosh.NAME, 'obj', 1066, 8, 1066, 11),
woosh.Token(woosh.OP, '.', 1066, 11, 1066, 12),
woosh.Token(woosh.NAME, 'chksum', 1066, 12, 1066, 18),
woosh.Token(woosh.OP, '=', 1066, 19, 1066, 20),
woosh.Token(woosh.NAME, 'chksum', 1066, 21, 1066, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 1066, 27, 1067, 0),
woosh.Token(woosh.NAME, 'obj', 1067, 8, 1067, 11),
woosh.Token(woosh.OP, '.', 1067, 11, 1067, 12),
woosh.Token(woosh.NAME, 'type', 1067, 12, 1067, 16),
woosh.Token(woosh.OP, '=', 1067, 17, 1067, 18),
woosh.Token(woosh.NAME, 'buf', 1067, 19, 1067, 22),
woosh.Token(woosh.OP, '[', 1067, 22, 1067, 23),
woosh.Token(woosh.NUMBER, '156', 1067, 23, 1067, 26),
woosh.Token(woosh.OP, ':', 1067, 26, 1067, 27),
woosh.Token(woosh.NUMBER, '157', 1067, 27, 1067, 30),
woosh.Token(woosh.OP, ']', 1067, 30, 1067, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 1067, 31, 1068, 0),
woosh.Token(woosh.NAME, 'obj', 1068, 8, 1068, 11),
woosh.Token(woosh.OP, '.', 1068, 11, 1068, 12),
woosh.Token(woosh.NAME, 'linkname', 1068, 12, 1068, 20),
woosh.Token(woosh.OP, '=', 1068, 21, 1068, 22),
woosh.Token(woosh.NAME, 'nts', 1068, 23, 1068, 26),
woosh.Token(woosh.OP, '(', 1068, 26, 1068, 27),
woosh.Token(woosh.NAME, 'buf', 1068, 27, 1068, 30),
woosh.Token(woosh.OP, '[', 1068, 30, 1068, 31),
woosh.Token(woosh.NUMBER, '157', 1068, 31, 1068, 34),
woosh.Token(woosh.OP, ':', 1068, 34, 1068, 35),
woosh.Token(woosh.NUMBER, '257', 1068, 35, 1068, 38),
woosh.Token(woosh.OP, ']', 1068, 38, 1068, 39),
woosh.Token(woosh.OP, ',', 1068, 39, 1068, 40),
woosh.Token(woosh.NAME, 'encoding', 1068, 41, 1068, 49),
woosh.Token(woosh.OP, ',', 1068, 49, 1068, 50),
woosh.Token(woosh.NAME, 'errors', 1068, 51, 1068, 57),
woosh.Token(woosh.OP, ')', 1068, 57, 1068, 58),
woosh.Token(woosh.NEWLINE, '\r\n', 1068, 58, 1069, 0),
woosh.Token(woosh.NAME, 'obj', 1069, 8, 1069, 11),
woosh.Token(woosh.OP, '.', 1069, 11, 1069, 12),
woosh.Token(woosh.NAME, 'uname', 1069, 12, 1069, 17),
woosh.Token(woosh.OP, '=', 1069, 18, 1069, 19),
woosh.Token(woosh.NAME, 'nts', 1069, 20, 1069, 23),
woosh.Token(woosh.OP, '(', 1069, 23, 1069, 24),
woosh.Token(woosh.NAME, 'buf', 1069, 24, 1069, 27),
woosh.Token(woosh.OP, '[', 1069, 27, 1069, 28),
woosh.Token(woosh.NUMBER, '265', 1069, 28, 1069, 31),
woosh.Token(woosh.OP, ':', 1069, 31, 1069, 32),
woosh.Token(woosh.NUMBER, '297', 1069, 32, 1069, 35),
woosh.Token(woosh.OP, ']', 1069, 35, 1069, 36),
woosh.Token(woosh.OP, ',', 1069, 36, 1069, 37),
woosh.Token(woosh.NAME, 'encoding', 1069, 38, 1069, 46),
woosh.Token(woosh.OP, ',', 1069, 46, 1069, 47),
woosh.Token(woosh.NAME, 'errors', 1069, 48, 1069, 54),
woosh.Token(woosh.OP, ')', 1069, 54, 1069, 55),
woosh.Token(woosh.NEWLINE, '\r\n', 1069, 55, 1070, 0),
woosh.Token(woosh.NAME, 'obj', 1070, 8, 1070, 11),
woosh.Token(woosh.OP, '.', 1070, 11, 1070, 12),
woosh.Token(woosh.NAME, 'gname', 1070, 12, 1070, 17),
woosh.Token(woosh.OP, '=', 1070, 18, 1070, 19),
woosh.Token(woosh.NAME, 'nts', 1070, 20, 1070, 23),
woosh.Token(woosh.OP, '(', 1070, 23, 1070, 24),
woosh.Token(woosh.NAME, 'buf', 1070, 24, 1070, 27),
woosh.Token(woosh.OP, '[', 1070, 27, 1070, 28),
woosh.Token(woosh.NUMBER, '297', 1070, 28, 1070, 31),
woosh.Token(woosh.OP, ':', 1070, 31, 1070, 32),
woosh.Token(woosh.NUMBER, '329', 1070, 32, 1070, 35),
woosh.Token(woosh.OP, ']', 1070, 35, 1070, 36),
woosh.Token(woosh.OP, ',', 1070, 36, 1070, 37),
woosh.Token(woosh.NAME, 'encoding', 1070, 38, 1070, 46),
woosh.Token(woosh.OP, ',', 1070, 46, 1070, 47),
woosh.Token(woosh.NAME, 'errors', 1070, 48, 1070, 54),
woosh.Token(woosh.OP, ')', 1070, 54, 1070, 55),
woosh.Token(woosh.NEWLINE, '\r\n', 1070, 55, 1071, 0),
woosh.Token(woosh.NAME, 'obj', 1071, 8, 1071, 11),
woosh.Token(woosh.OP, '.', 1071, 11, 1071, 12),
woosh.Token(woosh.NAME, 'devmajor', 1071, 12, 1071, 20),
woosh.Token(woosh.OP, '=', 1071, 21, 1071, 22),
woosh.Token(woosh.NAME, 'nti', 1071, 23, 1071, 26),
woosh.Token(woosh.OP, '(', 1071, 26, 1071, 27),
woosh.Token(woosh.NAME, 'buf', 1071, 27, 1071, 30),
woosh.Token(woosh.OP, '[', 1071, 30, 1071, 31),
woosh.Token(woosh.NUMBER, '329', 1071, 31, 1071, 34),
woosh.Token(woosh.OP, ':', 1071, 34, 1071, 35),
woosh.Token(woosh.NUMBER, '337', 1071, 35, 1071, 38),
woosh.Token(woosh.OP, ']', 1071, 38, 1071, 39),
woosh.Token(woosh.OP, ')', 1071, 39, 1071, 40),
woosh.Token(woosh.NEWLINE, '\r\n', 1071, 40, 1072, 0),
woosh.Token(woosh.NAME, 'obj', 1072, 8, 1072, 11),
woosh.Token(woosh.OP, '.', 1072, 11, 1072, 12),
woosh.Token(woosh.NAME, 'devminor', 1072, 12, 1072, 20),
woosh.Token(woosh.OP, '=', 1072, 21, 1072, 22),
woosh.Token(woosh.NAME, 'nti', 1072, 23, 1072, 26),
woosh.Token(woosh.OP, '(', 1072, 26, 1072, 27),
woosh.Token(woosh.NAME, 'buf', 1072, 27, 1072, 30),
woosh.Token(woosh.OP, '[', 1072, 30, 1072, 31),
woosh.Token(woosh.NUMBER, '337', 1072, 31, 1072, 34),
woosh.Token(woosh.OP, ':', 1072, 34, 1072, 35),
woosh.Token(woosh.NUMBER, '345', 1072, 35, 1072, 38),
woosh.Token(woosh.OP, ']', 1072, 38, 1072, 39),
woosh.Token(woosh.OP, ')', 1072, 39, 1072, 40),
woosh.Token(woosh.NEWLINE, '\r\n', 1072, 40, 1073, 0),
woosh.Token(woosh.NAME, 'prefix', 1073, 8, 1073, 14),
woosh.Token(woosh.OP, '=', 1073, 15, 1073, 16),
woosh.Token(woosh.NAME, 'nts', 1073, 17, 1073, 20),
woosh.Token(woosh.OP, '(', 1073, 20, 1073, 21),
woosh.Token(woosh.NAME, 'buf', 1073, 21, 1073, 24),
woosh.Token(woosh.OP, '[', 1073, 24, 1073, 25),
woosh.Token(woosh.NUMBER, '345', 1073, 25, 1073, 28),
woosh.Token(woosh.OP, ':', 1073, 28, 1073, 29),
woosh.Token(woosh.NUMBER, '500', 1073, 29, 1073, 32),
woosh.Token(woosh.OP, ']', 1073, 32, 1073, 33),
woosh.Token(woosh.OP, ',', 1073, 33, 1073, 34),
woosh.Token(woosh.NAME, 'encoding', 1073, 35, 1073, 43),
woosh.Token(woosh.OP, ',', 1073, 43, 1073, 44),
woosh.Token(woosh.NAME, 'errors', 1073, 45, 1073, 51),
woosh.Token(woosh.OP, ')', 1073, 51, 1073, 52),
woosh.Token(woosh.NEWLINE, '\r\n', 1073, 52, 1074, 0),
woosh.Token(woosh.COMMENT, '# Old V7 tar format represents a directory as a regular', 1075, 8, 1075, 63),
woosh.Token(woosh.COMMENT, '# file with a trailing slash.', 1076, 8, 1076, 37),
woosh.Token(woosh.NAME, 'if', 1077, 8, 1077, 10),
woosh.Token(woosh.NAME, 'obj', 1077, 11, 1077, 14),
woosh.Token(woosh.OP, '.', 1077, 14, 1077, 15),
woosh.Token(woosh.NAME, 'type', 1077, 15, 1077, 19),
woosh.Token(woosh.OP, '==', 1077, 20, 1077, 22),
woosh.Token(woosh.NAME, 'AREGTYPE', 1077, 23, 1077, 31),
woosh.Token(woosh.NAME, 'and', 1077, 32, 1077, 35),
woosh.Token(woosh.NAME, 'obj', 1077, 36, 1077, 39),
woosh.Token(woosh.OP, '.', 1077, 39, 1077, 40),
woosh.Token(woosh.NAME, 'name', 1077, 40, 1077, 44),
woosh.Token(woosh.OP, '.', 1077, 44, 1077, 45),
woosh.Token(woosh.NAME, 'endswith', 1077, 45, 1077, 53),
woosh.Token(woosh.OP, '(', 1077, 53, 1077, 54),
woosh.Token(woosh.STRING, '"/"', 1077, 54, 1077, 57),
woosh.Token(woosh.OP, ')', 1077, 57, 1077, 58),
woosh.Token(woosh.OP, ':', 1077, 58, 1077, 59),
woosh.Token(woosh.NEWLINE, '\r\n', 1077, 59, 1078, 0),
woosh.Token(woosh.INDENT, ' ', 1078, 0, 1078, 12),
woosh.Token(woosh.NAME, 'obj', 1078, 12, 1078, 15),
woosh.Token(woosh.OP, '.', 1078, 15, 1078, 16),
woosh.Token(woosh.NAME, 'type', 1078, 16, 1078, 20),
woosh.Token(woosh.OP, '=', 1078, 21, 1078, 22),
woosh.Token(woosh.NAME, 'DIRTYPE', 1078, 23, 1078, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 1078, 30, 1079, 0),
woosh.Token(woosh.COMMENT, '# The old GNU sparse format occupies some of the unused', 1080, 8, 1080, 63),
woosh.Token(woosh.COMMENT, '# space in the buffer for up to 4 sparse structures.', 1081, 8, 1081, 60),
woosh.Token(woosh.COMMENT, '# Save them for later processing in _proc_sparse().', 1082, 8, 1082, 59),
woosh.Token(woosh.DEDENT, ' ', 1083, 0, 1083, 8),
woosh.Token(woosh.NAME, 'if', 1083, 8, 1083, 10),
woosh.Token(woosh.NAME, 'obj', 1083, 11, 1083, 14),
woosh.Token(woosh.OP, '.', 1083, 14, 1083, 15),
woosh.Token(woosh.NAME, 'type', 1083, 15, 1083, 19),
woosh.Token(woosh.OP, '==', 1083, 20, 1083, 22),
woosh.Token(woosh.NAME, 'GNUTYPE_SPARSE', 1083, 23, 1083, 37),
woosh.Token(woosh.OP, ':', 1083, 37, 1083, 38),
woosh.Token(woosh.NEWLINE, '\r\n', 1083, 38, 1084, 0),
woosh.Token(woosh.INDENT, ' ', 1084, 0, 1084, 12),
woosh.Token(woosh.NAME, 'pos', 1084, 12, 1084, 15),
woosh.Token(woosh.OP, '=', 1084, 16, 1084, 17),
woosh.Token(woosh.NUMBER, '386', 1084, 18, 1084, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 1084, 21, 1085, 0),
woosh.Token(woosh.NAME, 'structs', 1085, 12, 1085, 19),
woosh.Token(woosh.OP, '=', 1085, 20, 1085, 21),
woosh.Token(woosh.OP, '[', 1085, 22, 1085, 23),
woosh.Token(woosh.OP, ']', 1085, 23, 1085, 24),
woosh.Token(woosh.NEWLINE, '\r\n', 1085, 24, 1086, 0),
woosh.Token(woosh.NAME, 'for', 1086, 12, 1086, 15),
woosh.Token(woosh.NAME, 'i', 1086, 16, 1086, 17),
woosh.Token(woosh.NAME, 'in', 1086, 18, 1086, 20),
woosh.Token(woosh.NAME, 'range', 1086, 21, 1086, 26),
woosh.Token(woosh.OP, '(', 1086, 26, 1086, 27),
woosh.Token(woosh.NUMBER, '4', 1086, 27, 1086, 28),
woosh.Token(woosh.OP, ')', 1086, 28, 1086, 29),
woosh.Token(woosh.OP, ':', 1086, 29, 1086, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 1086, 30, 1087, 0),
woosh.Token(woosh.INDENT, ' ', 1087, 0, 1087, 16),
woosh.Token(woosh.NAME, 'try', 1087, 16, 1087, 19),
woosh.Token(woosh.OP, ':', 1087, 19, 1087, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 1087, 20, 1088, 0),
woosh.Token(woosh.INDENT, ' ', 1088, 0, 1088, 20),
woosh.Token(woosh.NAME, 'offset', 1088, 20, 1088, 26),
woosh.Token(woosh.OP, '=', 1088, 27, 1088, 28),
woosh.Token(woosh.NAME, 'nti', 1088, 29, 1088, 32),
woosh.Token(woosh.OP, '(', 1088, 32, 1088, 33),
woosh.Token(woosh.NAME, 'buf', 1088, 33, 1088, 36),
woosh.Token(woosh.OP, '[', 1088, 36, 1088, 37),
woosh.Token(woosh.NAME, 'pos', 1088, 37, 1088, 40),
woosh.Token(woosh.OP, ':', 1088, 40, 1088, 41),
woosh.Token(woosh.NAME, 'pos', 1088, 41, 1088, 44),
woosh.Token(woosh.OP, '+', 1088, 45, 1088, 46),
woosh.Token(woosh.NUMBER, '12', 1088, 47, 1088, 49),
woosh.Token(woosh.OP, ']', 1088, 49, 1088, 50),
woosh.Token(woosh.OP, ')', 1088, 50, 1088, 51),
woosh.Token(woosh.NEWLINE, '\r\n', 1088, 51, 1089, 0),
woosh.Token(woosh.NAME, 'numbytes', 1089, 20, 1089, 28),
woosh.Token(woosh.OP, '=', 1089, 29, 1089, 30),
woosh.Token(woosh.NAME, 'nti', 1089, 31, 1089, 34),
woosh.Token(woosh.OP, '(', 1089, 34, 1089, 35),
woosh.Token(woosh.NAME, 'buf', 1089, 35, 1089, 38),
woosh.Token(woosh.OP, '[', 1089, 38, 1089, 39),
woosh.Token(woosh.NAME, 'pos', 1089, 39, 1089, 42),
woosh.Token(woosh.OP, '+', 1089, 43, 1089, 44),
woosh.Token(woosh.NUMBER, '12', 1089, 45, 1089, 47),
woosh.Token(woosh.OP, ':', 1089, 47, 1089, 48),
woosh.Token(woosh.NAME, 'pos', 1089, 48, 1089, 51),
woosh.Token(woosh.OP, '+', 1089, 52, 1089, 53),
woosh.Token(woosh.NUMBER, '24', 1089, 54, 1089, 56),
woosh.Token(woosh.OP, ']', 1089, 56, 1089, 57),
woosh.Token(woosh.OP, ')', 1089, 57, 1089, 58),
woosh.Token(woosh.NEWLINE, '\r\n', 1089, 58, 1090, 0),
woosh.Token(woosh.DEDENT, ' ', 1090, 0, 1090, 16),
woosh.Token(woosh.NAME, 'except', 1090, 16, 1090, 22),
woosh.Token(woosh.NAME, 'ValueError', 1090, 23, 1090, 33),
woosh.Token(woosh.OP, ':', 1090, 33, 1090, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 1090, 34, 1091, 0),
woosh.Token(woosh.INDENT, ' ', 1091, 0, 1091, 20),
woosh.Token(woosh.NAME, 'break', 1091, 20, 1091, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 1091, 25, 1092, 0),
woosh.Token(woosh.DEDENT, ' ', 1092, 0, 1092, 16),
woosh.Token(woosh.NAME, 'structs', 1092, 16, 1092, 23),
woosh.Token(woosh.OP, '.', 1092, 23, 1092, 24),
woosh.Token(woosh.NAME, 'append', 1092, 24, 1092, 30),
woosh.Token(woosh.OP, '(', 1092, 30, 1092, 31),
woosh.Token(woosh.OP, '(', 1092, 31, 1092, 32),
woosh.Token(woosh.NAME, 'offset', 1092, 32, 1092, 38),
woosh.Token(woosh.OP, ',', 1092, 38, 1092, 39),
woosh.Token(woosh.NAME, 'numbytes', 1092, 40, 1092, 48),
woosh.Token(woosh.OP, ')', 1092, 48, 1092, 49),
woosh.Token(woosh.OP, ')', 1092, 49, 1092, 50),
woosh.Token(woosh.NEWLINE, '\r\n', 1092, 50, 1093, 0),
woosh.Token(woosh.NAME, 'pos', 1093, 16, 1093, 19),
woosh.Token(woosh.OP, '+=', 1093, 20, 1093, 22),
woosh.Token(woosh.NUMBER, '24', 1093, 23, 1093, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 1093, 25, 1094, 0),
woosh.Token(woosh.DEDENT, ' ', 1094, 0, 1094, 12),
woosh.Token(woosh.NAME, 'isextended', 1094, 12, 1094, 22),
woosh.Token(woosh.OP, '=', 1094, 23, 1094, 24),
woosh.Token(woosh.NAME, 'bool', 1094, 25, 1094, 29),
woosh.Token(woosh.OP, '(', 1094, 29, 1094, 30),
woosh.Token(woosh.NAME, 'buf', 1094, 30, 1094, 33),
woosh.Token(woosh.OP, '[', 1094, 33, 1094, 34),
woosh.Token(woosh.NUMBER, '482', 1094, 34, 1094, 37),
woosh.Token(woosh.OP, ']', 1094, 37, 1094, 38),
woosh.Token(woosh.OP, ')', 1094, 38, 1094, 39),
woosh.Token(woosh.NEWLINE, '\r\n', 1094, 39, 1095, 0),
woosh.Token(woosh.NAME, 'origsize', 1095, 12, 1095, 20),
woosh.Token(woosh.OP, '=', 1095, 21, 1095, 22),
woosh.Token(woosh.NAME, 'nti', 1095, 23, 1095, 26),
woosh.Token(woosh.OP, '(', 1095, 26, 1095, 27),
woosh.Token(woosh.NAME, 'buf', 1095, 27, 1095, 30),
woosh.Token(woosh.OP, '[', 1095, 30, 1095, 31),
woosh.Token(woosh.NUMBER, '483', 1095, 31, 1095, 34),
woosh.Token(woosh.OP, ':', 1095, 34, 1095, 35),
woosh.Token(woosh.NUMBER, '495', 1095, 35, 1095, 38),
woosh.Token(woosh.OP, ']', 1095, 38, 1095, 39),
woosh.Token(woosh.OP, ')', 1095, 39, 1095, 40),
woosh.Token(woosh.NEWLINE, '\r\n', 1095, 40, 1096, 0),
woosh.Token(woosh.NAME, 'obj', 1096, 12, 1096, 15),
woosh.Token(woosh.OP, '.', 1096, 15, 1096, 16),
woosh.Token(woosh.NAME, '_sparse_structs', 1096, 16, 1096, 31),
woosh.Token(woosh.OP, '=', 1096, 32, 1096, 33),
woosh.Token(woosh.OP, '(', 1096, 34, 1096, 35),
woosh.Token(woosh.NAME, 'structs', 1096, 35, 1096, 42),
woosh.Token(woosh.OP, ',', 1096, 42, 1096, 43),
woosh.Token(woosh.NAME, 'isextended', 1096, 44, 1096, 54),
woosh.Token(woosh.OP, ',', 1096, 54, 1096, 55),
woosh.Token(woosh.NAME, 'origsize', 1096, 56, 1096, 64),
woosh.Token(woosh.OP, ')', 1096, 64, 1096, 65),
woosh.Token(woosh.NEWLINE, '\r\n', 1096, 65, 1097, 0),
woosh.Token(woosh.COMMENT, '# Remove redundant slashes from directories.', 1098, 8, 1098, 52),
woosh.Token(woosh.DEDENT, ' ', 1099, 0, 1099, 8),
woosh.Token(woosh.NAME, 'if', 1099, 8, 1099, 10),
woosh.Token(woosh.NAME, 'obj', 1099, 11, 1099, 14),
woosh.Token(woosh.OP, '.', 1099, 14, 1099, 15),
woosh.Token(woosh.NAME, 'isdir', 1099, 15, 1099, 20),
woosh.Token(woosh.OP, '(', 1099, 20, 1099, 21),
woosh.Token(woosh.OP, ')', 1099, 21, 1099, 22),
woosh.Token(woosh.OP, ':', 1099, 22, 1099, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 1099, 23, 1100, 0),
woosh.Token(woosh.INDENT, ' ', 1100, 0, 1100, 12),
woosh.Token(woosh.NAME, 'obj', 1100, 12, 1100, 15),
woosh.Token(woosh.OP, '.', 1100, 15, 1100, 16),
woosh.Token(woosh.NAME, 'name', 1100, 16, 1100, 20),
woosh.Token(woosh.OP, '=', 1100, 21, 1100, 22),
woosh.Token(woosh.NAME, 'obj', 1100, 23, 1100, 26),
woosh.Token(woosh.OP, '.', 1100, 26, 1100, 27),
woosh.Token(woosh.NAME, 'name', 1100, 27, 1100, 31),
woosh.Token(woosh.OP, '.', 1100, 31, 1100, 32),
woosh.Token(woosh.NAME, 'rstrip', 1100, 32, 1100, 38),
woosh.Token(woosh.OP, '(', 1100, 38, 1100, 39),
woosh.Token(woosh.STRING, '"/"', 1100, 39, 1100, 42),
woosh.Token(woosh.OP, ')', 1100, 42, 1100, 43),
woosh.Token(woosh.NEWLINE, '\r\n', 1100, 43, 1101, 0),
woosh.Token(woosh.COMMENT, '# Reconstruct a ustar longname.', 1102, 8, 1102, 39),
woosh.Token(woosh.DEDENT, ' ', 1103, 0, 1103, 8),
woosh.Token(woosh.NAME, 'if', 1103, 8, 1103, 10),
woosh.Token(woosh.NAME, 'prefix', 1103, 11, 1103, 17),
woosh.Token(woosh.NAME, 'and', 1103, 18, 1103, 21),
woosh.Token(woosh.NAME, 'obj', 1103, 22, 1103, 25),
woosh.Token(woosh.OP, '.', 1103, 25, 1103, 26),
woosh.Token(woosh.NAME, 'type', 1103, 26, 1103, 30),
woosh.Token(woosh.NAME, 'not', 1103, 31, 1103, 34),
woosh.Token(woosh.NAME, 'in', 1103, 35, 1103, 37),
woosh.Token(woosh.NAME, 'GNU_TYPES', 1103, 38, 1103, 47),
woosh.Token(woosh.OP, ':', 1103, 47, 1103, 48),
woosh.Token(woosh.NEWLINE, '\r\n', 1103, 48, 1104, 0),
woosh.Token(woosh.INDENT, ' ', 1104, 0, 1104, 12),
woosh.Token(woosh.NAME, 'obj', 1104, 12, 1104, 15),
woosh.Token(woosh.OP, '.', 1104, 15, 1104, 16),
woosh.Token(woosh.NAME, 'name', 1104, 16, 1104, 20),
woosh.Token(woosh.OP, '=', 1104, 21, 1104, 22),
woosh.Token(woosh.NAME, 'prefix', 1104, 23, 1104, 29),
woosh.Token(woosh.OP, '+', 1104, 30, 1104, 31),
woosh.Token(woosh.STRING, '"/"', 1104, 32, 1104, 35),
woosh.Token(woosh.OP, '+', 1104, 36, 1104, 37),
woosh.Token(woosh.NAME, 'obj', 1104, 38, 1104, 41),
woosh.Token(woosh.OP, '.', 1104, 41, 1104, 42),
woosh.Token(woosh.NAME, 'name', 1104, 42, 1104, 46),
woosh.Token(woosh.NEWLINE, '\r\n', 1104, 46, 1105, 0),
woosh.Token(woosh.DEDENT, ' ', 1105, 0, 1105, 8),
woosh.Token(woosh.NAME, 'return', 1105, 8, 1105, 14),
woosh.Token(woosh.NAME, 'obj', 1105, 15, 1105, 18),
woosh.Token(woosh.NEWLINE, '\r\n', 1105, 18, 1106, 0),
woosh.Token(woosh.DEDENT, ' ', 1107, 0, 1107, 4),
woosh.Token(woosh.OP, '@', 1107, 4, 1107, 5),
woosh.Token(woosh.NAME, 'classmethod', 1107, 5, 1107, 16),
woosh.Token(woosh.NEWLINE, '\r\n', 1107, 16, 1108, 0),
woosh.Token(woosh.NAME, 'def', 1108, 4, 1108, 7),
woosh.Token(woosh.NAME, 'fromtarfile', 1108, 8, 1108, 19),
woosh.Token(woosh.OP, '(', 1108, 19, 1108, 20),
woosh.Token(woosh.NAME, 'cls', 1108, 20, 1108, 23),
woosh.Token(woosh.OP, ',', 1108, 23, 1108, 24),
woosh.Token(woosh.NAME, 'tarfile', 1108, 25, 1108, 32),
woosh.Token(woosh.OP, ')', 1108, 32, 1108, 33),
woosh.Token(woosh.OP, ':', 1108, 33, 1108, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 1108, 34, 1109, 0),
woosh.Token(woosh.INDENT, ' ', 1109, 0, 1109, 8),
woosh.Token(woosh.STRING, '"""Return the next TarInfo object from TarFile object\r\n tarfile.\r\n """', 1109, 8, 1111, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 1111, 11, 1112, 0),
woosh.Token(woosh.NAME, 'buf', 1112, 8, 1112, 11),
woosh.Token(woosh.OP, '=', 1112, 12, 1112, 13),
woosh.Token(woosh.NAME, 'tarfile', 1112, 14, 1112, 21),
woosh.Token(woosh.OP, '.', 1112, 21, 1112, 22),
woosh.Token(woosh.NAME, 'fileobj', 1112, 22, 1112, 29),
woosh.Token(woosh.OP, '.', 1112, 29, 1112, 30),
woosh.Token(woosh.NAME, 'read', 1112, 30, 1112, 34),
woosh.Token(woosh.OP, '(', 1112, 34, 1112, 35),
woosh.Token(woosh.NAME, 'BLOCKSIZE', 1112, 35, 1112, 44),
woosh.Token(woosh.OP, ')', 1112, 44, 1112, 45),
woosh.Token(woosh.NEWLINE, '\r\n', 1112, 45, 1113, 0),
woosh.Token(woosh.NAME, 'obj', 1113, 8, 1113, 11),
woosh.Token(woosh.OP, '=', 1113, 12, 1113, 13),
woosh.Token(woosh.NAME, 'cls', 1113, 14, 1113, 17),
woosh.Token(woosh.OP, '.', 1113, 17, 1113, 18),
woosh.Token(woosh.NAME, 'frombuf', 1113, 18, 1113, 25),
woosh.Token(woosh.OP, '(', 1113, 25, 1113, 26),
woosh.Token(woosh.NAME, 'buf', 1113, 26, 1113, 29),
woosh.Token(woosh.OP, ',', 1113, 29, 1113, 30),
woosh.Token(woosh.NAME, 'tarfile', 1113, 31, 1113, 38),
woosh.Token(woosh.OP, '.', 1113, 38, 1113, 39),
woosh.Token(woosh.NAME, 'encoding', 1113, 39, 1113, 47),
woosh.Token(woosh.OP, ',', 1113, 47, 1113, 48),
woosh.Token(woosh.NAME, 'tarfile', 1113, 49, 1113, 56),
woosh.Token(woosh.OP, '.', 1113, 56, 1113, 57),
woosh.Token(woosh.NAME, 'errors', 1113, 57, 1113, 63),
woosh.Token(woosh.OP, ')', 1113, 63, 1113, 64),
woosh.Token(woosh.NEWLINE, '\r\n', 1113, 64, 1114, 0),
woosh.Token(woosh.NAME, 'obj', 1114, 8, 1114, 11),
woosh.Token(woosh.OP, '.', 1114, 11, 1114, 12),
woosh.Token(woosh.NAME, 'offset', 1114, 12, 1114, 18),
woosh.Token(woosh.OP, '=', 1114, 19, 1114, 20),
woosh.Token(woosh.NAME, 'tarfile', 1114, 21, 1114, 28),
woosh.Token(woosh.OP, '.', 1114, 28, 1114, 29),
woosh.Token(woosh.NAME, 'fileobj', 1114, 29, 1114, 36),
woosh.Token(woosh.OP, '.', 1114, 36, 1114, 37),
woosh.Token(woosh.NAME, 'tell', 1114, 37, 1114, 41),
woosh.Token(woosh.OP, '(', 1114, 41, 1114, 42),
woosh.Token(woosh.OP, ')', 1114, 42, 1114, 43),
woosh.Token(woosh.OP, '-', 1114, 44, 1114, 45),
woosh.Token(woosh.NAME, 'BLOCKSIZE', 1114, 46, 1114, 55),
woosh.Token(woosh.NEWLINE, '\r\n', 1114, 55, 1115, 0),
woosh.Token(woosh.NAME, 'return', 1115, 8, 1115, 14),
woosh.Token(woosh.NAME, 'obj', 1115, 15, 1115, 18),
woosh.Token(woosh.OP, '.', 1115, 18, 1115, 19),
woosh.Token(woosh.NAME, '_proc_member', 1115, 19, 1115, 31),
woosh.Token(woosh.OP, '(', 1115, 31, 1115, 32),
woosh.Token(woosh.NAME, 'tarfile', 1115, 32, 1115, 39),
woosh.Token(woosh.OP, ')', 1115, 39, 1115, 40),
woosh.Token(woosh.NEWLINE, '\r\n', 1115, 40, 1116, 0),
woosh.Token(woosh.COMMENT, '#--------------------------------------------------------------------------', 1117, 4, 1117, 79),
woosh.Token(woosh.COMMENT, '# The following are methods that are called depending on the type of a', 1118, 4, 1118, 74),
woosh.Token(woosh.COMMENT, '# member. The entry point is _proc_member() which can be overridden in a', 1119, 4, 1119, 76),
woosh.Token(woosh.COMMENT, '# subclass to add custom _proc_*() methods. A _proc_*() method MUST', 1120, 4, 1120, 71),
woosh.Token(woosh.COMMENT, '# implement the following', 1121, 4, 1121, 29),
woosh.Token(woosh.COMMENT, '# operations:', 1122, 4, 1122, 17),
woosh.Token(woosh.COMMENT, '# 1. Set self.offset_data to the position where the data blocks begin,', 1123, 4, 1123, 74),
woosh.Token(woosh.COMMENT, '# if there is data that follows.', 1124, 4, 1124, 39),
woosh.Token(woosh.COMMENT, "# 2. Set tarfile.offset to the position where the next member's header will", 1125, 4, 1125, 79),
woosh.Token(woosh.COMMENT, '# begin.', 1126, 4, 1126, 15),
woosh.Token(woosh.COMMENT, '# 3. Return self or another valid TarInfo object.', 1127, 4, 1127, 53),
woosh.Token(woosh.DEDENT, ' ', 1128, 0, 1128, 4),
woosh.Token(woosh.NAME, 'def', 1128, 4, 1128, 7),
woosh.Token(woosh.NAME, '_proc_member', 1128, 8, 1128, 20),
woosh.Token(woosh.OP, '(', 1128, 20, 1128, 21),
woosh.Token(woosh.NAME, 'self', 1128, 21, 1128, 25),
woosh.Token(woosh.OP, ',', 1128, 25, 1128, 26),
woosh.Token(woosh.NAME, 'tarfile', 1128, 27, 1128, 34),
woosh.Token(woosh.OP, ')', 1128, 34, 1128, 35),
woosh.Token(woosh.OP, ':', 1128, 35, 1128, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 1128, 36, 1129, 0),
woosh.Token(woosh.INDENT, ' ', 1129, 0, 1129, 8),
woosh.Token(woosh.STRING, '"""Choose the right processing method depending on\r\n the type and call it.\r\n """', 1129, 8, 1131, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 1131, 11, 1132, 0),
woosh.Token(woosh.NAME, 'if', 1132, 8, 1132, 10),
woosh.Token(woosh.NAME, 'self', 1132, 11, 1132, 15),
woosh.Token(woosh.OP, '.', 1132, 15, 1132, 16),
woosh.Token(woosh.NAME, 'type', 1132, 16, 1132, 20),
woosh.Token(woosh.NAME, 'in', 1132, 21, 1132, 23),
woosh.Token(woosh.OP, '(', 1132, 24, 1132, 25),
woosh.Token(woosh.NAME, 'GNUTYPE_LONGNAME', 1132, 25, 1132, 41),
woosh.Token(woosh.OP, ',', 1132, 41, 1132, 42),
woosh.Token(woosh.NAME, 'GNUTYPE_LONGLINK', 1132, 43, 1132, 59),
woosh.Token(woosh.OP, ')', 1132, 59, 1132, 60),
woosh.Token(woosh.OP, ':', 1132, 60, 1132, 61),
woosh.Token(woosh.NEWLINE, '\r\n', 1132, 61, 1133, 0),
woosh.Token(woosh.INDENT, ' ', 1133, 0, 1133, 12),
woosh.Token(woosh.NAME, 'return', 1133, 12, 1133, 18),
woosh.Token(woosh.NAME, 'self', 1133, 19, 1133, 23),
woosh.Token(woosh.OP, '.', 1133, 23, 1133, 24),
woosh.Token(woosh.NAME, '_proc_gnulong', 1133, 24, 1133, 37),
woosh.Token(woosh.OP, '(', 1133, 37, 1133, 38),
woosh.Token(woosh.NAME, 'tarfile', 1133, 38, 1133, 45),
woosh.Token(woosh.OP, ')', 1133, 45, 1133, 46),
woosh.Token(woosh.NEWLINE, '\r\n', 1133, 46, 1134, 0),
woosh.Token(woosh.DEDENT, ' ', 1134, 0, 1134, 8),
woosh.Token(woosh.NAME, 'elif', 1134, 8, 1134, 12),
woosh.Token(woosh.NAME, 'self', 1134, 13, 1134, 17),
woosh.Token(woosh.OP, '.', 1134, 17, 1134, 18),
woosh.Token(woosh.NAME, 'type', 1134, 18, 1134, 22),
woosh.Token(woosh.OP, '==', 1134, 23, 1134, 25),
woosh.Token(woosh.NAME, 'GNUTYPE_SPARSE', 1134, 26, 1134, 40),
woosh.Token(woosh.OP, ':', 1134, 40, 1134, 41),
woosh.Token(woosh.NEWLINE, '\r\n', 1134, 41, 1135, 0),
woosh.Token(woosh.INDENT, ' ', 1135, 0, 1135, 12),
woosh.Token(woosh.NAME, 'return', 1135, 12, 1135, 18),
woosh.Token(woosh.NAME, 'self', 1135, 19, 1135, 23),
woosh.Token(woosh.OP, '.', 1135, 23, 1135, 24),
woosh.Token(woosh.NAME, '_proc_sparse', 1135, 24, 1135, 36),
woosh.Token(woosh.OP, '(', 1135, 36, 1135, 37),
woosh.Token(woosh.NAME, 'tarfile', 1135, 37, 1135, 44),
woosh.Token(woosh.OP, ')', 1135, 44, 1135, 45),
woosh.Token(woosh.NEWLINE, '\r\n', 1135, 45, 1136, 0),
woosh.Token(woosh.DEDENT, ' ', 1136, 0, 1136, 8),
woosh.Token(woosh.NAME, 'elif', 1136, 8, 1136, 12),
woosh.Token(woosh.NAME, 'self', 1136, 13, 1136, 17),
woosh.Token(woosh.OP, '.', 1136, 17, 1136, 18),
woosh.Token(woosh.NAME, 'type', 1136, 18, 1136, 22),
woosh.Token(woosh.NAME, 'in', 1136, 23, 1136, 25),
woosh.Token(woosh.OP, '(', 1136, 26, 1136, 27),
woosh.Token(woosh.NAME, 'XHDTYPE', 1136, 27, 1136, 34),
woosh.Token(woosh.OP, ',', 1136, 34, 1136, 35),
woosh.Token(woosh.NAME, 'XGLTYPE', 1136, 36, 1136, 43),
woosh.Token(woosh.OP, ',', 1136, 43, 1136, 44),
woosh.Token(woosh.NAME, 'SOLARIS_XHDTYPE', 1136, 45, 1136, 60),
woosh.Token(woosh.OP, ')', 1136, 60, 1136, 61),
woosh.Token(woosh.OP, ':', 1136, 61, 1136, 62),
woosh.Token(woosh.NEWLINE, '\r\n', 1136, 62, 1137, 0),
woosh.Token(woosh.INDENT, ' ', 1137, 0, 1137, 12),
woosh.Token(woosh.NAME, 'return', 1137, 12, 1137, 18),
woosh.Token(woosh.NAME, 'self', 1137, 19, 1137, 23),
woosh.Token(woosh.OP, '.', 1137, 23, 1137, 24),
woosh.Token(woosh.NAME, '_proc_pax', 1137, 24, 1137, 33),
woosh.Token(woosh.OP, '(', 1137, 33, 1137, 34),
woosh.Token(woosh.NAME, 'tarfile', 1137, 34, 1137, 41),
woosh.Token(woosh.OP, ')', 1137, 41, 1137, 42),
woosh.Token(woosh.NEWLINE, '\r\n', 1137, 42, 1138, 0),
woosh.Token(woosh.DEDENT, ' ', 1138, 0, 1138, 8),
woosh.Token(woosh.NAME, 'else', 1138, 8, 1138, 12),
woosh.Token(woosh.OP, ':', 1138, 12, 1138, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 1138, 13, 1139, 0),
woosh.Token(woosh.INDENT, ' ', 1139, 0, 1139, 12),
woosh.Token(woosh.NAME, 'return', 1139, 12, 1139, 18),
woosh.Token(woosh.NAME, 'self', 1139, 19, 1139, 23),
woosh.Token(woosh.OP, '.', 1139, 23, 1139, 24),
woosh.Token(woosh.NAME, '_proc_builtin', 1139, 24, 1139, 37),
woosh.Token(woosh.OP, '(', 1139, 37, 1139, 38),
woosh.Token(woosh.NAME, 'tarfile', 1139, 38, 1139, 45),
woosh.Token(woosh.OP, ')', 1139, 45, 1139, 46),
woosh.Token(woosh.NEWLINE, '\r\n', 1139, 46, 1140, 0),
woosh.Token(woosh.DEDENT, ' ', 1141, 0, 1141, 4),
woosh.Token(woosh.DEDENT, '', 1141, 4, 1141, 4),
woosh.Token(woosh.NAME, 'def', 1141, 4, 1141, 7),
woosh.Token(woosh.NAME, '_proc_builtin', 1141, 8, 1141, 21),
woosh.Token(woosh.OP, '(', 1141, 21, 1141, 22),
woosh.Token(woosh.NAME, 'self', 1141, 22, 1141, 26),
woosh.Token(woosh.OP, ',', 1141, 26, 1141, 27),
woosh.Token(woosh.NAME, 'tarfile', 1141, 28, 1141, 35),
woosh.Token(woosh.OP, ')', 1141, 35, 1141, 36),
woosh.Token(woosh.OP, ':', 1141, 36, 1141, 37),
woosh.Token(woosh.NEWLINE, '\r\n', 1141, 37, 1142, 0),
woosh.Token(woosh.INDENT, ' ', 1142, 0, 1142, 8),
woosh.Token(woosh.STRING, '"""Process a builtin type or an unknown type which\r\n will be treated as a regular file.\r\n """', 1142, 8, 1144, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 1144, 11, 1145, 0),
woosh.Token(woosh.NAME, 'self', 1145, 8, 1145, 12),
woosh.Token(woosh.OP, '.', 1145, 12, 1145, 13),
woosh.Token(woosh.NAME, 'offset_data', 1145, 13, 1145, 24),
woosh.Token(woosh.OP, '=', 1145, 25, 1145, 26),
woosh.Token(woosh.NAME, 'tarfile', 1145, 27, 1145, 34),
woosh.Token(woosh.OP, '.', 1145, 34, 1145, 35),
woosh.Token(woosh.NAME, 'fileobj', 1145, 35, 1145, 42),
woosh.Token(woosh.OP, '.', 1145, 42, 1145, 43),
woosh.Token(woosh.NAME, 'tell', 1145, 43, 1145, 47),
woosh.Token(woosh.OP, '(', 1145, 47, 1145, 48),
woosh.Token(woosh.OP, ')', 1145, 48, 1145, 49),
woosh.Token(woosh.NEWLINE, '\r\n', 1145, 49, 1146, 0),
woosh.Token(woosh.NAME, 'offset', 1146, 8, 1146, 14),
woosh.Token(woosh.OP, '=', 1146, 15, 1146, 16),
woosh.Token(woosh.NAME, 'self', 1146, 17, 1146, 21),
woosh.Token(woosh.OP, '.', 1146, 21, 1146, 22),
woosh.Token(woosh.NAME, 'offset_data', 1146, 22, 1146, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 1146, 33, 1147, 0),
woosh.Token(woosh.NAME, 'if', 1147, 8, 1147, 10),
woosh.Token(woosh.NAME, 'self', 1147, 11, 1147, 15),
woosh.Token(woosh.OP, '.', 1147, 15, 1147, 16),
woosh.Token(woosh.NAME, 'isreg', 1147, 16, 1147, 21),
woosh.Token(woosh.OP, '(', 1147, 21, 1147, 22),
woosh.Token(woosh.OP, ')', 1147, 22, 1147, 23),
woosh.Token(woosh.NAME, 'or', 1147, 24, 1147, 26),
woosh.Token(woosh.NAME, 'self', 1147, 27, 1147, 31),
woosh.Token(woosh.OP, '.', 1147, 31, 1147, 32),
woosh.Token(woosh.NAME, 'type', 1147, 32, 1147, 36),
woosh.Token(woosh.NAME, 'not', 1147, 37, 1147, 40),
woosh.Token(woosh.NAME, 'in', 1147, 41, 1147, 43),
woosh.Token(woosh.NAME, 'SUPPORTED_TYPES', 1147, 44, 1147, 59),
woosh.Token(woosh.OP, ':', 1147, 59, 1147, 60),
woosh.Token(woosh.NEWLINE, '\r\n', 1147, 60, 1148, 0),
woosh.Token(woosh.COMMENT, '# Skip the following data blocks.', 1148, 12, 1148, 45),
woosh.Token(woosh.INDENT, ' ', 1149, 0, 1149, 12),
woosh.Token(woosh.NAME, 'offset', 1149, 12, 1149, 18),
woosh.Token(woosh.OP, '+=', 1149, 19, 1149, 21),
woosh.Token(woosh.NAME, 'self', 1149, 22, 1149, 26),
woosh.Token(woosh.OP, '.', 1149, 26, 1149, 27),
woosh.Token(woosh.NAME, '_block', 1149, 27, 1149, 33),
woosh.Token(woosh.OP, '(', 1149, 33, 1149, 34),
woosh.Token(woosh.NAME, 'self', 1149, 34, 1149, 38),
woosh.Token(woosh.OP, '.', 1149, 38, 1149, 39),
woosh.Token(woosh.NAME, 'size', 1149, 39, 1149, 43),
woosh.Token(woosh.OP, ')', 1149, 43, 1149, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 1149, 44, 1150, 0),
woosh.Token(woosh.DEDENT, ' ', 1150, 0, 1150, 8),
woosh.Token(woosh.NAME, 'tarfile', 1150, 8, 1150, 15),
woosh.Token(woosh.OP, '.', 1150, 15, 1150, 16),
woosh.Token(woosh.NAME, 'offset', 1150, 16, 1150, 22),
woosh.Token(woosh.OP, '=', 1150, 23, 1150, 24),
woosh.Token(woosh.NAME, 'offset', 1150, 25, 1150, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 1150, 31, 1151, 0),
woosh.Token(woosh.COMMENT, '# Patch the TarInfo object with saved global', 1152, 8, 1152, 52),
woosh.Token(woosh.COMMENT, '# header information.', 1153, 8, 1153, 29),
woosh.Token(woosh.NAME, 'self', 1154, 8, 1154, 12),
woosh.Token(woosh.OP, '.', 1154, 12, 1154, 13),
woosh.Token(woosh.NAME, '_apply_pax_info', 1154, 13, 1154, 28),
woosh.Token(woosh.OP, '(', 1154, 28, 1154, 29),
woosh.Token(woosh.NAME, 'tarfile', 1154, 29, 1154, 36),
woosh.Token(woosh.OP, '.', 1154, 36, 1154, 37),
woosh.Token(woosh.NAME, 'pax_headers', 1154, 37, 1154, 48),
woosh.Token(woosh.OP, ',', 1154, 48, 1154, 49),
woosh.Token(woosh.NAME, 'tarfile', 1154, 50, 1154, 57),
woosh.Token(woosh.OP, '.', 1154, 57, 1154, 58),
woosh.Token(woosh.NAME, 'encoding', 1154, 58, 1154, 66),
woosh.Token(woosh.OP, ',', 1154, 66, 1154, 67),
woosh.Token(woosh.NAME, 'tarfile', 1154, 68, 1154, 75),
woosh.Token(woosh.OP, '.', 1154, 75, 1154, 76),
woosh.Token(woosh.NAME, 'errors', 1154, 76, 1154, 82),
woosh.Token(woosh.OP, ')', 1154, 82, 1154, 83),
woosh.Token(woosh.NEWLINE, '\r\n', 1154, 83, 1155, 0),
woosh.Token(woosh.NAME, 'return', 1156, 8, 1156, 14),
woosh.Token(woosh.NAME, 'self', 1156, 15, 1156, 19),
woosh.Token(woosh.NEWLINE, '\r\n', 1156, 19, 1157, 0),
woosh.Token(woosh.DEDENT, ' ', 1158, 0, 1158, 4),
woosh.Token(woosh.NAME, 'def', 1158, 4, 1158, 7),
woosh.Token(woosh.NAME, '_proc_gnulong', 1158, 8, 1158, 21),
woosh.Token(woosh.OP, '(', 1158, 21, 1158, 22),
woosh.Token(woosh.NAME, 'self', 1158, 22, 1158, 26),
woosh.Token(woosh.OP, ',', 1158, 26, 1158, 27),
woosh.Token(woosh.NAME, 'tarfile', 1158, 28, 1158, 35),
woosh.Token(woosh.OP, ')', 1158, 35, 1158, 36),
woosh.Token(woosh.OP, ':', 1158, 36, 1158, 37),
woosh.Token(woosh.NEWLINE, '\r\n', 1158, 37, 1159, 0),
woosh.Token(woosh.INDENT, ' ', 1159, 0, 1159, 8),
woosh.Token(woosh.STRING, '"""Process the blocks that hold a GNU longname\r\n or longlink member.\r\n """', 1159, 8, 1161, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 1161, 11, 1162, 0),
woosh.Token(woosh.NAME, 'buf', 1162, 8, 1162, 11),
woosh.Token(woosh.OP, '=', 1162, 12, 1162, 13),
woosh.Token(woosh.NAME, 'tarfile', 1162, 14, 1162, 21),
woosh.Token(woosh.OP, '.', 1162, 21, 1162, 22),
woosh.Token(woosh.NAME, 'fileobj', 1162, 22, 1162, 29),
woosh.Token(woosh.OP, '.', 1162, 29, 1162, 30),
woosh.Token(woosh.NAME, 'read', 1162, 30, 1162, 34),
woosh.Token(woosh.OP, '(', 1162, 34, 1162, 35),
woosh.Token(woosh.NAME, 'self', 1162, 35, 1162, 39),
woosh.Token(woosh.OP, '.', 1162, 39, 1162, 40),
woosh.Token(woosh.NAME, '_block', 1162, 40, 1162, 46),
woosh.Token(woosh.OP, '(', 1162, 46, 1162, 47),
woosh.Token(woosh.NAME, 'self', 1162, 47, 1162, 51),
woosh.Token(woosh.OP, '.', 1162, 51, 1162, 52),
woosh.Token(woosh.NAME, 'size', 1162, 52, 1162, 56),
woosh.Token(woosh.OP, ')', 1162, 56, 1162, 57),
woosh.Token(woosh.OP, ')', 1162, 57, 1162, 58),
woosh.Token(woosh.NEWLINE, '\r\n', 1162, 58, 1163, 0),
woosh.Token(woosh.COMMENT, '# Fetch the next header and process it.', 1164, 8, 1164, 47),
woosh.Token(woosh.NAME, 'try', 1165, 8, 1165, 11),
woosh.Token(woosh.OP, ':', 1165, 11, 1165, 12),
woosh.Token(woosh.NEWLINE, '\r\n', 1165, 12, 1166, 0),
woosh.Token(woosh.INDENT, ' ', 1166, 0, 1166, 12),
woosh.Token(woosh.NAME, 'next', 1166, 12, 1166, 16),
woosh.Token(woosh.OP, '=', 1166, 17, 1166, 18),
woosh.Token(woosh.NAME, 'self', 1166, 19, 1166, 23),
woosh.Token(woosh.OP, '.', 1166, 23, 1166, 24),
woosh.Token(woosh.NAME, 'fromtarfile', 1166, 24, 1166, 35),
woosh.Token(woosh.OP, '(', 1166, 35, 1166, 36),
woosh.Token(woosh.NAME, 'tarfile', 1166, 36, 1166, 43),
woosh.Token(woosh.OP, ')', 1166, 43, 1166, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 1166, 44, 1167, 0),
woosh.Token(woosh.DEDENT, ' ', 1167, 0, 1167, 8),
woosh.Token(woosh.NAME, 'except', 1167, 8, 1167, 14),
woosh.Token(woosh.NAME, 'HeaderError', 1167, 15, 1167, 26),
woosh.Token(woosh.OP, ':', 1167, 26, 1167, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 1167, 27, 1168, 0),
woosh.Token(woosh.INDENT, ' ', 1168, 0, 1168, 12),
woosh.Token(woosh.NAME, 'raise', 1168, 12, 1168, 17),
woosh.Token(woosh.NAME, 'SubsequentHeaderError', 1168, 18, 1168, 39),
woosh.Token(woosh.OP, '(', 1168, 39, 1168, 40),
woosh.Token(woosh.STRING, '"missing or bad subsequent header"', 1168, 40, 1168, 74),
woosh.Token(woosh.OP, ')', 1168, 74, 1168, 75),
woosh.Token(woosh.NEWLINE, '\r\n', 1168, 75, 1169, 0),
woosh.Token(woosh.COMMENT, '# Patch the TarInfo object from the next header with', 1170, 8, 1170, 60),
woosh.Token(woosh.COMMENT, '# the longname information.', 1171, 8, 1171, 35),
woosh.Token(woosh.DEDENT, ' ', 1172, 0, 1172, 8),
woosh.Token(woosh.NAME, 'next', 1172, 8, 1172, 12),
woosh.Token(woosh.OP, '.', 1172, 12, 1172, 13),
woosh.Token(woosh.NAME, 'offset', 1172, 13, 1172, 19),
woosh.Token(woosh.OP, '=', 1172, 20, 1172, 21),
woosh.Token(woosh.NAME, 'self', 1172, 22, 1172, 26),
woosh.Token(woosh.OP, '.', 1172, 26, 1172, 27),
woosh.Token(woosh.NAME, 'offset', 1172, 27, 1172, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 1172, 33, 1173, 0),
woosh.Token(woosh.NAME, 'if', 1173, 8, 1173, 10),
woosh.Token(woosh.NAME, 'self', 1173, 11, 1173, 15),
woosh.Token(woosh.OP, '.', 1173, 15, 1173, 16),
woosh.Token(woosh.NAME, 'type', 1173, 16, 1173, 20),
woosh.Token(woosh.OP, '==', 1173, 21, 1173, 23),
woosh.Token(woosh.NAME, 'GNUTYPE_LONGNAME', 1173, 24, 1173, 40),
woosh.Token(woosh.OP, ':', 1173, 40, 1173, 41),
woosh.Token(woosh.NEWLINE, '\r\n', 1173, 41, 1174, 0),
woosh.Token(woosh.INDENT, ' ', 1174, 0, 1174, 12),
woosh.Token(woosh.NAME, 'next', 1174, 12, 1174, 16),
woosh.Token(woosh.OP, '.', 1174, 16, 1174, 17),
woosh.Token(woosh.NAME, 'name', 1174, 17, 1174, 21),
woosh.Token(woosh.OP, '=', 1174, 22, 1174, 23),
woosh.Token(woosh.NAME, 'nts', 1174, 24, 1174, 27),
woosh.Token(woosh.OP, '(', 1174, 27, 1174, 28),
woosh.Token(woosh.NAME, 'buf', 1174, 28, 1174, 31),
woosh.Token(woosh.OP, ',', 1174, 31, 1174, 32),
woosh.Token(woosh.NAME, 'tarfile', 1174, 33, 1174, 40),
woosh.Token(woosh.OP, '.', 1174, 40, 1174, 41),
woosh.Token(woosh.NAME, 'encoding', 1174, 41, 1174, 49),
woosh.Token(woosh.OP, ',', 1174, 49, 1174, 50),
woosh.Token(woosh.NAME, 'tarfile', 1174, 51, 1174, 58),
woosh.Token(woosh.OP, '.', 1174, 58, 1174, 59),
woosh.Token(woosh.NAME, 'errors', 1174, 59, 1174, 65),
woosh.Token(woosh.OP, ')', 1174, 65, 1174, 66),
woosh.Token(woosh.NEWLINE, '\r\n', 1174, 66, 1175, 0),
woosh.Token(woosh.DEDENT, ' ', 1175, 0, 1175, 8),
woosh.Token(woosh.NAME, 'elif', 1175, 8, 1175, 12),
woosh.Token(woosh.NAME, 'self', 1175, 13, 1175, 17),
woosh.Token(woosh.OP, '.', 1175, 17, 1175, 18),
woosh.Token(woosh.NAME, 'type', 1175, 18, 1175, 22),
woosh.Token(woosh.OP, '==', 1175, 23, 1175, 25),
woosh.Token(woosh.NAME, 'GNUTYPE_LONGLINK', 1175, 26, 1175, 42),
woosh.Token(woosh.OP, ':', 1175, 42, 1175, 43),
woosh.Token(woosh.NEWLINE, '\r\n', 1175, 43, 1176, 0),
woosh.Token(woosh.INDENT, ' ', 1176, 0, 1176, 12),
woosh.Token(woosh.NAME, 'next', 1176, 12, 1176, 16),
woosh.Token(woosh.OP, '.', 1176, 16, 1176, 17),
woosh.Token(woosh.NAME, 'linkname', 1176, 17, 1176, 25),
woosh.Token(woosh.OP, '=', 1176, 26, 1176, 27),
woosh.Token(woosh.NAME, 'nts', 1176, 28, 1176, 31),
woosh.Token(woosh.OP, '(', 1176, 31, 1176, 32),
woosh.Token(woosh.NAME, 'buf', 1176, 32, 1176, 35),
woosh.Token(woosh.OP, ',', 1176, 35, 1176, 36),
woosh.Token(woosh.NAME, 'tarfile', 1176, 37, 1176, 44),
woosh.Token(woosh.OP, '.', 1176, 44, 1176, 45),
woosh.Token(woosh.NAME, 'encoding', 1176, 45, 1176, 53),
woosh.Token(woosh.OP, ',', 1176, 53, 1176, 54),
woosh.Token(woosh.NAME, 'tarfile', 1176, 55, 1176, 62),
woosh.Token(woosh.OP, '.', 1176, 62, 1176, 63),
woosh.Token(woosh.NAME, 'errors', 1176, 63, 1176, 69),
woosh.Token(woosh.OP, ')', 1176, 69, 1176, 70),
woosh.Token(woosh.NEWLINE, '\r\n', 1176, 70, 1177, 0),
woosh.Token(woosh.DEDENT, ' ', 1178, 0, 1178, 8),
woosh.Token(woosh.NAME, 'return', 1178, 8, 1178, 14),
woosh.Token(woosh.NAME, 'next', 1178, 15, 1178, 19),
woosh.Token(woosh.NEWLINE, '\r\n', 1178, 19, 1179, 0),
woosh.Token(woosh.DEDENT, ' ', 1180, 0, 1180, 4),
woosh.Token(woosh.NAME, 'def', 1180, 4, 1180, 7),
woosh.Token(woosh.NAME, '_proc_sparse', 1180, 8, 1180, 20),
woosh.Token(woosh.OP, '(', 1180, 20, 1180, 21),
woosh.Token(woosh.NAME, 'self', 1180, 21, 1180, 25),
woosh.Token(woosh.OP, ',', 1180, 25, 1180, 26),
woosh.Token(woosh.NAME, 'tarfile', 1180, 27, 1180, 34),
woosh.Token(woosh.OP, ')', 1180, 34, 1180, 35),
woosh.Token(woosh.OP, ':', 1180, 35, 1180, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 1180, 36, 1181, 0),
woosh.Token(woosh.INDENT, ' ', 1181, 0, 1181, 8),
woosh.Token(woosh.STRING, '"""Process a GNU sparse header plus extra headers.\r\n """', 1181, 8, 1182, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 1182, 11, 1183, 0),
woosh.Token(woosh.COMMENT, '# We already collected some sparse structures in frombuf().', 1183, 8, 1183, 67),
woosh.Token(woosh.NAME, 'structs', 1184, 8, 1184, 15),
woosh.Token(woosh.OP, ',', 1184, 15, 1184, 16),
woosh.Token(woosh.NAME, 'isextended', 1184, 17, 1184, 27),
woosh.Token(woosh.OP, ',', 1184, 27, 1184, 28),
woosh.Token(woosh.NAME, 'origsize', 1184, 29, 1184, 37),
woosh.Token(woosh.OP, '=', 1184, 38, 1184, 39),
woosh.Token(woosh.NAME, 'self', 1184, 40, 1184, 44),
woosh.Token(woosh.OP, '.', 1184, 44, 1184, 45),
woosh.Token(woosh.NAME, '_sparse_structs', 1184, 45, 1184, 60),
woosh.Token(woosh.NEWLINE, '\r\n', 1184, 60, 1185, 0),
woosh.Token(woosh.NAME, 'del', 1185, 8, 1185, 11),
woosh.Token(woosh.NAME, 'self', 1185, 12, 1185, 16),
woosh.Token(woosh.OP, '.', 1185, 16, 1185, 17),
woosh.Token(woosh.NAME, '_sparse_structs', 1185, 17, 1185, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 1185, 32, 1186, 0),
woosh.Token(woosh.COMMENT, '# Collect sparse structures from extended header blocks.', 1187, 8, 1187, 64),
woosh.Token(woosh.NAME, 'while', 1188, 8, 1188, 13),
woosh.Token(woosh.NAME, 'isextended', 1188, 14, 1188, 24),
woosh.Token(woosh.OP, ':', 1188, 24, 1188, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 1188, 25, 1189, 0),
woosh.Token(woosh.INDENT, ' ', 1189, 0, 1189, 12),
woosh.Token(woosh.NAME, 'buf', 1189, 12, 1189, 15),
woosh.Token(woosh.OP, '=', 1189, 16, 1189, 17),
woosh.Token(woosh.NAME, 'tarfile', 1189, 18, 1189, 25),
woosh.Token(woosh.OP, '.', 1189, 25, 1189, 26),
woosh.Token(woosh.NAME, 'fileobj', 1189, 26, 1189, 33),
woosh.Token(woosh.OP, '.', 1189, 33, 1189, 34),
woosh.Token(woosh.NAME, 'read', 1189, 34, 1189, 38),
woosh.Token(woosh.OP, '(', 1189, 38, 1189, 39),
woosh.Token(woosh.NAME, 'BLOCKSIZE', 1189, 39, 1189, 48),
woosh.Token(woosh.OP, ')', 1189, 48, 1189, 49),
woosh.Token(woosh.NEWLINE, '\r\n', 1189, 49, 1190, 0),
woosh.Token(woosh.NAME, 'pos', 1190, 12, 1190, 15),
woosh.Token(woosh.OP, '=', 1190, 16, 1190, 17),
woosh.Token(woosh.NUMBER, '0', 1190, 18, 1190, 19),
woosh.Token(woosh.NEWLINE, '\r\n', 1190, 19, 1191, 0),
woosh.Token(woosh.NAME, 'for', 1191, 12, 1191, 15),
woosh.Token(woosh.NAME, 'i', 1191, 16, 1191, 17),
woosh.Token(woosh.NAME, 'in', 1191, 18, 1191, 20),
woosh.Token(woosh.NAME, 'range', 1191, 21, 1191, 26),
woosh.Token(woosh.OP, '(', 1191, 26, 1191, 27),
woosh.Token(woosh.NUMBER, '21', 1191, 27, 1191, 29),
woosh.Token(woosh.OP, ')', 1191, 29, 1191, 30),
woosh.Token(woosh.OP, ':', 1191, 30, 1191, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 1191, 31, 1192, 0),
woosh.Token(woosh.INDENT, ' ', 1192, 0, 1192, 16),
woosh.Token(woosh.NAME, 'try', 1192, 16, 1192, 19),
woosh.Token(woosh.OP, ':', 1192, 19, 1192, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 1192, 20, 1193, 0),
woosh.Token(woosh.INDENT, ' ', 1193, 0, 1193, 20),
woosh.Token(woosh.NAME, 'offset', 1193, 20, 1193, 26),
woosh.Token(woosh.OP, '=', 1193, 27, 1193, 28),
woosh.Token(woosh.NAME, 'nti', 1193, 29, 1193, 32),
woosh.Token(woosh.OP, '(', 1193, 32, 1193, 33),
woosh.Token(woosh.NAME, 'buf', 1193, 33, 1193, 36),
woosh.Token(woosh.OP, '[', 1193, 36, 1193, 37),
woosh.Token(woosh.NAME, 'pos', 1193, 37, 1193, 40),
woosh.Token(woosh.OP, ':', 1193, 40, 1193, 41),
woosh.Token(woosh.NAME, 'pos', 1193, 41, 1193, 44),
woosh.Token(woosh.OP, '+', 1193, 45, 1193, 46),
woosh.Token(woosh.NUMBER, '12', 1193, 47, 1193, 49),
woosh.Token(woosh.OP, ']', 1193, 49, 1193, 50),
woosh.Token(woosh.OP, ')', 1193, 50, 1193, 51),
woosh.Token(woosh.NEWLINE, '\r\n', 1193, 51, 1194, 0),
woosh.Token(woosh.NAME, 'numbytes', 1194, 20, 1194, 28),
woosh.Token(woosh.OP, '=', 1194, 29, 1194, 30),
woosh.Token(woosh.NAME, 'nti', 1194, 31, 1194, 34),
woosh.Token(woosh.OP, '(', 1194, 34, 1194, 35),
woosh.Token(woosh.NAME, 'buf', 1194, 35, 1194, 38),
woosh.Token(woosh.OP, '[', 1194, 38, 1194, 39),
woosh.Token(woosh.NAME, 'pos', 1194, 39, 1194, 42),
woosh.Token(woosh.OP, '+', 1194, 43, 1194, 44),
woosh.Token(woosh.NUMBER, '12', 1194, 45, 1194, 47),
woosh.Token(woosh.OP, ':', 1194, 47, 1194, 48),
woosh.Token(woosh.NAME, 'pos', 1194, 48, 1194, 51),
woosh.Token(woosh.OP, '+', 1194, 52, 1194, 53),
woosh.Token(woosh.NUMBER, '24', 1194, 54, 1194, 56),
woosh.Token(woosh.OP, ']', 1194, 56, 1194, 57),
woosh.Token(woosh.OP, ')', 1194, 57, 1194, 58),
woosh.Token(woosh.NEWLINE, '\r\n', 1194, 58, 1195, 0),
woosh.Token(woosh.DEDENT, ' ', 1195, 0, 1195, 16),
woosh.Token(woosh.NAME, 'except', 1195, 16, 1195, 22),
woosh.Token(woosh.NAME, 'ValueError', 1195, 23, 1195, 33),
woosh.Token(woosh.OP, ':', 1195, 33, 1195, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 1195, 34, 1196, 0),
woosh.Token(woosh.INDENT, ' ', 1196, 0, 1196, 20),
woosh.Token(woosh.NAME, 'break', 1196, 20, 1196, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 1196, 25, 1197, 0),
woosh.Token(woosh.DEDENT, ' ', 1197, 0, 1197, 16),
woosh.Token(woosh.NAME, 'if', 1197, 16, 1197, 18),
woosh.Token(woosh.NAME, 'offset', 1197, 19, 1197, 25),
woosh.Token(woosh.NAME, 'and', 1197, 26, 1197, 29),
woosh.Token(woosh.NAME, 'numbytes', 1197, 30, 1197, 38),
woosh.Token(woosh.OP, ':', 1197, 38, 1197, 39),
woosh.Token(woosh.NEWLINE, '\r\n', 1197, 39, 1198, 0),
woosh.Token(woosh.INDENT, ' ', 1198, 0, 1198, 20),
woosh.Token(woosh.NAME, 'structs', 1198, 20, 1198, 27),
woosh.Token(woosh.OP, '.', 1198, 27, 1198, 28),
woosh.Token(woosh.NAME, 'append', 1198, 28, 1198, 34),
woosh.Token(woosh.OP, '(', 1198, 34, 1198, 35),
woosh.Token(woosh.OP, '(', 1198, 35, 1198, 36),
woosh.Token(woosh.NAME, 'offset', 1198, 36, 1198, 42),
woosh.Token(woosh.OP, ',', 1198, 42, 1198, 43),
woosh.Token(woosh.NAME, 'numbytes', 1198, 44, 1198, 52),
woosh.Token(woosh.OP, ')', 1198, 52, 1198, 53),
woosh.Token(woosh.OP, ')', 1198, 53, 1198, 54),
woosh.Token(woosh.NEWLINE, '\r\n', 1198, 54, 1199, 0),
woosh.Token(woosh.DEDENT, ' ', 1199, 0, 1199, 16),
woosh.Token(woosh.NAME, 'pos', 1199, 16, 1199, 19),
woosh.Token(woosh.OP, '+=', 1199, 20, 1199, 22),
woosh.Token(woosh.NUMBER, '24', 1199, 23, 1199, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 1199, 25, 1200, 0),
woosh.Token(woosh.DEDENT, ' ', 1200, 0, 1200, 12),
woosh.Token(woosh.NAME, 'isextended', 1200, 12, 1200, 22),
woosh.Token(woosh.OP, '=', 1200, 23, 1200, 24),
woosh.Token(woosh.NAME, 'bool', 1200, 25, 1200, 29),
woosh.Token(woosh.OP, '(', 1200, 29, 1200, 30),
woosh.Token(woosh.NAME, 'buf', 1200, 30, 1200, 33),
woosh.Token(woosh.OP, '[', 1200, 33, 1200, 34),
woosh.Token(woosh.NUMBER, '504', 1200, 34, 1200, 37),
woosh.Token(woosh.OP, ']', 1200, 37, 1200, 38),
woosh.Token(woosh.OP, ')', 1200, 38, 1200, 39),
woosh.Token(woosh.NEWLINE, '\r\n', 1200, 39, 1201, 0),
woosh.Token(woosh.DEDENT, ' ', 1201, 0, 1201, 8),
woosh.Token(woosh.NAME, 'self', 1201, 8, 1201, 12),
woosh.Token(woosh.OP, '.', 1201, 12, 1201, 13),
woosh.Token(woosh.NAME, 'sparse', 1201, 13, 1201, 19),
woosh.Token(woosh.OP, '=', 1201, 20, 1201, 21),
woosh.Token(woosh.NAME, 'structs', 1201, 22, 1201, 29),
woosh.Token(woosh.NEWLINE, '\r\n', 1201, 29, 1202, 0),
woosh.Token(woosh.NAME, 'self', 1203, 8, 1203, 12),
woosh.Token(woosh.OP, '.', 1203, 12, 1203, 13),
woosh.Token(woosh.NAME, 'offset_data', 1203, 13, 1203, 24),
woosh.Token(woosh.OP, '=', 1203, 25, 1203, 26),
woosh.Token(woosh.NAME, 'tarfile', 1203, 27, 1203, 34),
woosh.Token(woosh.OP, '.', 1203, 34, 1203, 35),
woosh.Token(woosh.NAME, 'fileobj', 1203, 35, 1203, 42),
woosh.Token(woosh.OP, '.', 1203, 42, 1203, 43),
woosh.Token(woosh.NAME, 'tell', 1203, 43, 1203, 47),
woosh.Token(woosh.OP, '(', 1203, 47, 1203, 48),
woosh.Token(woosh.OP, ')', 1203, 48, 1203, 49),
woosh.Token(woosh.NEWLINE, '\r\n', 1203, 49, 1204, 0),
woosh.Token(woosh.NAME, 'tarfile', 1204, 8, 1204, 15),
woosh.Token(woosh.OP, '.', 1204, 15, 1204, 16),
woosh.Token(woosh.NAME, 'offset', 1204, 16, 1204, 22),
woosh.Token(woosh.OP, '=', 1204, 23, 1204, 24),
woosh.Token(woosh.NAME, 'self', 1204, 25, 1204, 29),
woosh.Token(woosh.OP, '.', 1204, 29, 1204, 30),
woosh.Token(woosh.NAME, 'offset_data', 1204, 30, 1204, 41),
woosh.Token(woosh.OP, '+', 1204, 42, 1204, 43),
woosh.Token(woosh.NAME, 'self', 1204, 44, 1204, 48),
woosh.Token(woosh.OP, '.', 1204, 48, 1204, 49),
woosh.Token(woosh.NAME, '_block', 1204, 49, 1204, 55),
woosh.Token(woosh.OP, '(', 1204, 55, 1204, 56),
woosh.Token(woosh.NAME, 'self', 1204, 56, 1204, 60),
woosh.Token(woosh.OP, '.', 1204, 60, 1204, 61),
woosh.Token(woosh.NAME, 'size', 1204, 61, 1204, 65),
woosh.Token(woosh.OP, ')', 1204, 65, 1204, 66),
woosh.Token(woosh.NEWLINE, '\r\n', 1204, 66, 1205, 0),
woosh.Token(woosh.NAME, 'self', 1205, 8, 1205, 12),
woosh.Token(woosh.OP, '.', 1205, 12, 1205, 13),
woosh.Token(woosh.NAME, 'size', 1205, 13, 1205, 17),
woosh.Token(woosh.OP, '=', 1205, 18, 1205, 19),
woosh.Token(woosh.NAME, 'origsize', 1205, 20, 1205, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 1205, 28, 1206, 0),
woosh.Token(woosh.NAME, 'return', 1206, 8, 1206, 14),
woosh.Token(woosh.NAME, 'self', 1206, 15, 1206, 19),
woosh.Token(woosh.NEWLINE, '\r\n', 1206, 19, 1207, 0),
woosh.Token(woosh.DEDENT, ' ', 1208, 0, 1208, 4),
woosh.Token(woosh.NAME, 'def', 1208, 4, 1208, 7),
woosh.Token(woosh.NAME, '_proc_pax', 1208, 8, 1208, 17),
woosh.Token(woosh.OP, '(', 1208, 17, 1208, 18),
woosh.Token(woosh.NAME, 'self', 1208, 18, 1208, 22),
woosh.Token(woosh.OP, ',', 1208, 22, 1208, 23),
woosh.Token(woosh.NAME, 'tarfile', 1208, 24, 1208, 31),
woosh.Token(woosh.OP, ')', 1208, 31, 1208, 32),
woosh.Token(woosh.OP, ':', 1208, 32, 1208, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 1208, 33, 1209, 0),
woosh.Token(woosh.INDENT, ' ', 1209, 0, 1209, 8),
woosh.Token(woosh.STRING, '"""Process an extended or global header as described in\r\n POSIX.1-2008.\r\n """', 1209, 8, 1211, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 1211, 11, 1212, 0),
woosh.Token(woosh.COMMENT, '# Read the header information.', 1212, 8, 1212, 38),
woosh.Token(woosh.NAME, 'buf', 1213, 8, 1213, 11),
woosh.Token(woosh.OP, '=', 1213, 12, 1213, 13),
woosh.Token(woosh.NAME, 'tarfile', 1213, 14, 1213, 21),
woosh.Token(woosh.OP, '.', 1213, 21, 1213, 22),
woosh.Token(woosh.NAME, 'fileobj', 1213, 22, 1213, 29),
woosh.Token(woosh.OP, '.', 1213, 29, 1213, 30),
woosh.Token(woosh.NAME, 'read', 1213, 30, 1213, 34),
woosh.Token(woosh.OP, '(', 1213, 34, 1213, 35),
woosh.Token(woosh.NAME, 'self', 1213, 35, 1213, 39),
woosh.Token(woosh.OP, '.', 1213, 39, 1213, 40),
woosh.Token(woosh.NAME, '_block', 1213, 40, 1213, 46),
woosh.Token(woosh.OP, '(', 1213, 46, 1213, 47),
woosh.Token(woosh.NAME, 'self', 1213, 47, 1213, 51),
woosh.Token(woosh.OP, '.', 1213, 51, 1213, 52),
woosh.Token(woosh.NAME, 'size', 1213, 52, 1213, 56),
woosh.Token(woosh.OP, ')', 1213, 56, 1213, 57),
woosh.Token(woosh.OP, ')', 1213, 57, 1213, 58),
woosh.Token(woosh.NEWLINE, '\r\n', 1213, 58, 1214, 0),
woosh.Token(woosh.COMMENT, '# A pax header stores supplemental information for either', 1215, 8, 1215, 65),
woosh.Token(woosh.COMMENT, '# the following file (extended) or all following files', 1216, 8, 1216, 62),
woosh.Token(woosh.COMMENT, '# (global).', 1217, 8, 1217, 19),
woosh.Token(woosh.NAME, 'if', 1218, 8, 1218, 10),
woosh.Token(woosh.NAME, 'self', 1218, 11, 1218, 15),
woosh.Token(woosh.OP, '.', 1218, 15, 1218, 16),
woosh.Token(woosh.NAME, 'type', 1218, 16, 1218, 20),
woosh.Token(woosh.OP, '==', 1218, 21, 1218, 23),
woosh.Token(woosh.NAME, 'XGLTYPE', 1218, 24, 1218, 31),
woosh.Token(woosh.OP, ':', 1218, 31, 1218, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 1218, 32, 1219, 0),
woosh.Token(woosh.INDENT, ' ', 1219, 0, 1219, 12),
woosh.Token(woosh.NAME, 'pax_headers', 1219, 12, 1219, 23),
woosh.Token(woosh.OP, '=', 1219, 24, 1219, 25),
woosh.Token(woosh.NAME, 'tarfile', 1219, 26, 1219, 33),
woosh.Token(woosh.OP, '.', 1219, 33, 1219, 34),
woosh.Token(woosh.NAME, 'pax_headers', 1219, 34, 1219, 45),
woosh.Token(woosh.NEWLINE, '\r\n', 1219, 45, 1220, 0),
woosh.Token(woosh.DEDENT, ' ', 1220, 0, 1220, 8),
woosh.Token(woosh.NAME, 'else', 1220, 8, 1220, 12),
woosh.Token(woosh.OP, ':', 1220, 12, 1220, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 1220, 13, 1221, 0),
woosh.Token(woosh.INDENT, ' ', 1221, 0, 1221, 12),
woosh.Token(woosh.NAME, 'pax_headers', 1221, 12, 1221, 23),
woosh.Token(woosh.OP, '=', 1221, 24, 1221, 25),
woosh.Token(woosh.NAME, 'tarfile', 1221, 26, 1221, 33),
woosh.Token(woosh.OP, '.', 1221, 33, 1221, 34),
woosh.Token(woosh.NAME, 'pax_headers', 1221, 34, 1221, 45),
woosh.Token(woosh.OP, '.', 1221, 45, 1221, 46),
woosh.Token(woosh.NAME, 'copy', 1221, 46, 1221, 50),
woosh.Token(woosh.OP, '(', 1221, 50, 1221, 51),
woosh.Token(woosh.OP, ')', 1221, 51, 1221, 52),
woosh.Token(woosh.NEWLINE, '\r\n', 1221, 52, 1222, 0),
woosh.Token(woosh.COMMENT, '# Check if the pax header contains a hdrcharset field. This tells us', 1223, 8, 1223, 76),
woosh.Token(woosh.COMMENT, '# the encoding of the path, linkpath, uname and gname fields. Normally,', 1224, 8, 1224, 79),
woosh.Token(woosh.COMMENT, '# these fields are UTF-8 encoded but since POSIX.1-2008 tar', 1225, 8, 1225, 67),
woosh.Token(woosh.COMMENT, '# implementations are allowed to store them as raw binary strings if', 1226, 8, 1226, 76),
woosh.Token(woosh.COMMENT, '# the translation to UTF-8 fails.', 1227, 8, 1227, 41),
woosh.Token(woosh.DEDENT, ' ', 1228, 0, 1228, 8),
woosh.Token(woosh.NAME, 'match', 1228, 8, 1228, 13),
woosh.Token(woosh.OP, '=', 1228, 14, 1228, 15),
woosh.Token(woosh.NAME, 're', 1228, 16, 1228, 18),
woosh.Token(woosh.OP, '.', 1228, 18, 1228, 19),
woosh.Token(woosh.NAME, 'search', 1228, 19, 1228, 25),
woosh.Token(woosh.OP, '(', 1228, 25, 1228, 26),
woosh.Token(woosh.STRING, 'br"\\d+ hdrcharset=([^\\n]+)\\n"', 1228, 26, 1228, 55),
woosh.Token(woosh.OP, ',', 1228, 55, 1228, 56),
woosh.Token(woosh.NAME, 'buf', 1228, 57, 1228, 60),
woosh.Token(woosh.OP, ')', 1228, 60, 1228, 61),
woosh.Token(woosh.NEWLINE, '\r\n', 1228, 61, 1229, 0),
woosh.Token(woosh.NAME, 'if', 1229, 8, 1229, 10),
woosh.Token(woosh.NAME, 'match', 1229, 11, 1229, 16),
woosh.Token(woosh.NAME, 'is', 1229, 17, 1229, 19),
woosh.Token(woosh.NAME, 'not', 1229, 20, 1229, 23),
woosh.Token(woosh.NAME, 'None', 1229, 24, 1229, 28),
woosh.Token(woosh.OP, ':', 1229, 28, 1229, 29),
woosh.Token(woosh.NEWLINE, '\r\n', 1229, 29, 1230, 0),
woosh.Token(woosh.INDENT, ' ', 1230, 0, 1230, 12),
woosh.Token(woosh.NAME, 'pax_headers', 1230, 12, 1230, 23),
woosh.Token(woosh.OP, '[', 1230, 23, 1230, 24),
woosh.Token(woosh.STRING, '"hdrcharset"', 1230, 24, 1230, 36),
woosh.Token(woosh.OP, ']', 1230, 36, 1230, 37),
woosh.Token(woosh.OP, '=', 1230, 38, 1230, 39),
woosh.Token(woosh.NAME, 'match', 1230, 40, 1230, 45),
woosh.Token(woosh.OP, '.', 1230, 45, 1230, 46),
woosh.Token(woosh.NAME, 'group', 1230, 46, 1230, 51),
woosh.Token(woosh.OP, '(', 1230, 51, 1230, 52),
woosh.Token(woosh.NUMBER, '1', 1230, 52, 1230, 53),
woosh.Token(woosh.OP, ')', 1230, 53, 1230, 54),
woosh.Token(woosh.OP, '.', 1230, 54, 1230, 55),
woosh.Token(woosh.NAME, 'decode', 1230, 55, 1230, 61),
woosh.Token(woosh.OP, '(', 1230, 61, 1230, 62),
woosh.Token(woosh.STRING, '"utf-8"', 1230, 62, 1230, 69),
woosh.Token(woosh.OP, ')', 1230, 69, 1230, 70),
woosh.Token(woosh.NEWLINE, '\r\n', 1230, 70, 1231, 0),
woosh.Token(woosh.COMMENT, '# For the time being, we don\'t care about anything other than "BINARY".', 1232, 8, 1232, 79),
woosh.Token(woosh.COMMENT, '# The only other value that is currently allowed by the standard is', 1233, 8, 1233, 75),
woosh.Token(woosh.COMMENT, '# "ISO-IR 10646 2000 UTF-8" in other words UTF-8.', 1234, 8, 1234, 57),
woosh.Token(woosh.DEDENT, ' ', 1235, 0, 1235, 8),
woosh.Token(woosh.NAME, 'hdrcharset', 1235, 8, 1235, 18),
woosh.Token(woosh.OP, '=', 1235, 19, 1235, 20),
woosh.Token(woosh.NAME, 'pax_headers', 1235, 21, 1235, 32),
woosh.Token(woosh.OP, '.', 1235, 32, 1235, 33),
woosh.Token(woosh.NAME, 'get', 1235, 33, 1235, 36),
woosh.Token(woosh.OP, '(', 1235, 36, 1235, 37),
woosh.Token(woosh.STRING, '"hdrcharset"', 1235, 37, 1235, 49),
woosh.Token(woosh.OP, ')', 1235, 49, 1235, 50),
woosh.Token(woosh.NEWLINE, '\r\n', 1235, 50, 1236, 0),
woosh.Token(woosh.NAME, 'if', 1236, 8, 1236, 10),
woosh.Token(woosh.NAME, 'hdrcharset', 1236, 11, 1236, 21),
woosh.Token(woosh.OP, '==', 1236, 22, 1236, 24),
woosh.Token(woosh.STRING, '"BINARY"', 1236, 25, 1236, 33),
woosh.Token(woosh.OP, ':', 1236, 33, 1236, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 1236, 34, 1237, 0),
woosh.Token(woosh.INDENT, ' ', 1237, 0, 1237, 12),
woosh.Token(woosh.NAME, 'encoding', 1237, 12, 1237, 20),
woosh.Token(woosh.OP, '=', 1237, 21, 1237, 22),
woosh.Token(woosh.NAME, 'tarfile', 1237, 23, 1237, 30),
woosh.Token(woosh.OP, '.', 1237, 30, 1237, 31),
woosh.Token(woosh.NAME, 'encoding', 1237, 31, 1237, 39),
woosh.Token(woosh.NEWLINE, '\r\n', 1237, 39, 1238, 0),
woosh.Token(woosh.DEDENT, ' ', 1238, 0, 1238, 8),
woosh.Token(woosh.NAME, 'else', 1238, 8, 1238, 12),
woosh.Token(woosh.OP, ':', 1238, 12, 1238, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 1238, 13, 1239, 0),
woosh.Token(woosh.INDENT, ' ', 1239, 0, 1239, 12),
woosh.Token(woosh.NAME, 'encoding', 1239, 12, 1239, 20),
woosh.Token(woosh.OP, '=', 1239, 21, 1239, 22),
woosh.Token(woosh.STRING, '"utf-8"', 1239, 23, 1239, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 1239, 30, 1240, 0),
woosh.Token(woosh.COMMENT, '# Parse pax header information. A record looks like that:', 1241, 8, 1241, 65),
woosh.Token(woosh.COMMENT, '# "%d %s=%s\\n" % (length, keyword, value). length is the size', 1242, 8, 1242, 69),
woosh.Token(woosh.COMMENT, '# of the complete record including the length field itself and', 1243, 8, 1243, 70),
woosh.Token(woosh.COMMENT, '# the newline. keyword and value are both UTF-8 encoded strings.', 1244, 8, 1244, 72),
woosh.Token(woosh.DEDENT, ' ', 1245, 0, 1245, 8),
woosh.Token(woosh.NAME, 'regex', 1245, 8, 1245, 13),
woosh.Token(woosh.OP, '=', 1245, 14, 1245, 15),
woosh.Token(woosh.NAME, 're', 1245, 16, 1245, 18),
woosh.Token(woosh.OP, '.', 1245, 18, 1245, 19),
woosh.Token(woosh.NAME, 'compile', 1245, 19, 1245, 26),
woosh.Token(woosh.OP, '(', 1245, 26, 1245, 27),
woosh.Token(woosh.STRING, 'br"(\\d+) ([^=]+)="', 1245, 27, 1245, 45),
woosh.Token(woosh.OP, ')', 1245, 45, 1245, 46),
woosh.Token(woosh.NEWLINE, '\r\n', 1245, 46, 1246, 0),
woosh.Token(woosh.NAME, 'pos', 1246, 8, 1246, 11),
woosh.Token(woosh.OP, '=', 1246, 12, 1246, 13),
woosh.Token(woosh.NUMBER, '0', 1246, 14, 1246, 15),
woosh.Token(woosh.NEWLINE, '\r\n', 1246, 15, 1247, 0),
woosh.Token(woosh.NAME, 'while', 1247, 8, 1247, 13),
woosh.Token(woosh.NAME, 'True', 1247, 14, 1247, 18),
woosh.Token(woosh.OP, ':', 1247, 18, 1247, 19),
woosh.Token(woosh.NEWLINE, '\r\n', 1247, 19, 1248, 0),
woosh.Token(woosh.INDENT, ' ', 1248, 0, 1248, 12),
woosh.Token(woosh.NAME, 'match', 1248, 12, 1248, 17),
woosh.Token(woosh.OP, '=', 1248, 18, 1248, 19),
woosh.Token(woosh.NAME, 'regex', 1248, 20, 1248, 25),
woosh.Token(woosh.OP, '.', 1248, 25, 1248, 26),
woosh.Token(woosh.NAME, 'match', 1248, 26, 1248, 31),
woosh.Token(woosh.OP, '(', 1248, 31, 1248, 32),
woosh.Token(woosh.NAME, 'buf', 1248, 32, 1248, 35),
woosh.Token(woosh.OP, ',', 1248, 35, 1248, 36),
woosh.Token(woosh.NAME, 'pos', 1248, 37, 1248, 40),
woosh.Token(woosh.OP, ')', 1248, 40, 1248, 41),
woosh.Token(woosh.NEWLINE, '\r\n', 1248, 41, 1249, 0),
woosh.Token(woosh.NAME, 'if', 1249, 12, 1249, 14),
woosh.Token(woosh.NAME, 'not', 1249, 15, 1249, 18),
woosh.Token(woosh.NAME, 'match', 1249, 19, 1249, 24),
woosh.Token(woosh.OP, ':', 1249, 24, 1249, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 1249, 25, 1250, 0),
woosh.Token(woosh.INDENT, ' ', 1250, 0, 1250, 16),
woosh.Token(woosh.NAME, 'break', 1250, 16, 1250, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 1250, 21, 1251, 0),
woosh.Token(woosh.DEDENT, ' ', 1252, 0, 1252, 12),
woosh.Token(woosh.NAME, 'length', 1252, 12, 1252, 18),
woosh.Token(woosh.OP, ',', 1252, 18, 1252, 19),
woosh.Token(woosh.NAME, 'keyword', 1252, 20, 1252, 27),
woosh.Token(woosh.OP, '=', 1252, 28, 1252, 29),
woosh.Token(woosh.NAME, 'match', 1252, 30, 1252, 35),
woosh.Token(woosh.OP, '.', 1252, 35, 1252, 36),
woosh.Token(woosh.NAME, 'groups', 1252, 36, 1252, 42),
woosh.Token(woosh.OP, '(', 1252, 42, 1252, 43),
woosh.Token(woosh.OP, ')', 1252, 43, 1252, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 1252, 44, 1253, 0),
woosh.Token(woosh.NAME, 'length', 1253, 12, 1253, 18),
woosh.Token(woosh.OP, '=', 1253, 19, 1253, 20),
woosh.Token(woosh.NAME, 'int', 1253, 21, 1253, 24),
woosh.Token(woosh.OP, '(', 1253, 24, 1253, 25),
woosh.Token(woosh.NAME, 'length', 1253, 25, 1253, 31),
woosh.Token(woosh.OP, ')', 1253, 31, 1253, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 1253, 32, 1254, 0),
woosh.Token(woosh.NAME, 'if', 1254, 12, 1254, 14),
woosh.Token(woosh.NAME, 'length', 1254, 15, 1254, 21),
woosh.Token(woosh.OP, '==', 1254, 22, 1254, 24),
woosh.Token(woosh.NUMBER, '0', 1254, 25, 1254, 26),
woosh.Token(woosh.OP, ':', 1254, 26, 1254, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 1254, 27, 1255, 0),
woosh.Token(woosh.INDENT, ' ', 1255, 0, 1255, 16),
woosh.Token(woosh.NAME, 'raise', 1255, 16, 1255, 21),
woosh.Token(woosh.NAME, 'InvalidHeaderError', 1255, 22, 1255, 40),
woosh.Token(woosh.OP, '(', 1255, 40, 1255, 41),
woosh.Token(woosh.STRING, '"invalid header"', 1255, 41, 1255, 57),
woosh.Token(woosh.OP, ')', 1255, 57, 1255, 58),
woosh.Token(woosh.NEWLINE, '\r\n', 1255, 58, 1256, 0),
woosh.Token(woosh.DEDENT, ' ', 1256, 0, 1256, 12),
woosh.Token(woosh.NAME, 'value', 1256, 12, 1256, 17),
woosh.Token(woosh.OP, '=', 1256, 18, 1256, 19),
woosh.Token(woosh.NAME, 'buf', 1256, 20, 1256, 23),
woosh.Token(woosh.OP, '[', 1256, 23, 1256, 24),
woosh.Token(woosh.NAME, 'match', 1256, 24, 1256, 29),
woosh.Token(woosh.OP, '.', 1256, 29, 1256, 30),
woosh.Token(woosh.NAME, 'end', 1256, 30, 1256, 33),
woosh.Token(woosh.OP, '(', 1256, 33, 1256, 34),
woosh.Token(woosh.NUMBER, '2', 1256, 34, 1256, 35),
woosh.Token(woosh.OP, ')', 1256, 35, 1256, 36),
woosh.Token(woosh.OP, '+', 1256, 37, 1256, 38),
woosh.Token(woosh.NUMBER, '1', 1256, 39, 1256, 40),
woosh.Token(woosh.OP, ':', 1256, 40, 1256, 41),
woosh.Token(woosh.NAME, 'match', 1256, 41, 1256, 46),
woosh.Token(woosh.OP, '.', 1256, 46, 1256, 47),
woosh.Token(woosh.NAME, 'start', 1256, 47, 1256, 52),
woosh.Token(woosh.OP, '(', 1256, 52, 1256, 53),
woosh.Token(woosh.NUMBER, '1', 1256, 53, 1256, 54),
woosh.Token(woosh.OP, ')', 1256, 54, 1256, 55),
woosh.Token(woosh.OP, '+', 1256, 56, 1256, 57),
woosh.Token(woosh.NAME, 'length', 1256, 58, 1256, 64),
woosh.Token(woosh.OP, '-', 1256, 65, 1256, 66),
woosh.Token(woosh.NUMBER, '1', 1256, 67, 1256, 68),
woosh.Token(woosh.OP, ']', 1256, 68, 1256, 69),
woosh.Token(woosh.NEWLINE, '\r\n', 1256, 69, 1257, 0),
woosh.Token(woosh.COMMENT, '# Normally, we could just use "utf-8" as the encoding and "strict"', 1258, 12, 1258, 78),
woosh.Token(woosh.COMMENT, '# as the error handler, but we better not take the risk. For', 1259, 12, 1259, 72),
woosh.Token(woosh.COMMENT, '# example, GNU tar <= 1.23 is known to store filenames it cannot', 1260, 12, 1260, 76),
woosh.Token(woosh.COMMENT, '# translate to UTF-8 as raw strings (unfortunately without a', 1261, 12, 1261, 72),
woosh.Token(woosh.COMMENT, '# hdrcharset=BINARY header).', 1262, 12, 1262, 40),
woosh.Token(woosh.COMMENT, '# We first try the strict standard encoding, and if that fails we', 1263, 12, 1263, 77),
woosh.Token(woosh.COMMENT, "# fall back on the user's encoding and error handler.", 1264, 12, 1264, 65),
woosh.Token(woosh.NAME, 'keyword', 1265, 12, 1265, 19),
woosh.Token(woosh.OP, '=', 1265, 20, 1265, 21),
woosh.Token(woosh.NAME, 'self', 1265, 22, 1265, 26),
woosh.Token(woosh.OP, '.', 1265, 26, 1265, 27),
woosh.Token(woosh.NAME, '_decode_pax_field', 1265, 27, 1265, 44),
woosh.Token(woosh.OP, '(', 1265, 44, 1265, 45),
woosh.Token(woosh.NAME, 'keyword', 1265, 45, 1265, 52),
woosh.Token(woosh.OP, ',', 1265, 52, 1265, 53),
woosh.Token(woosh.STRING, '"utf-8"', 1265, 54, 1265, 61),
woosh.Token(woosh.OP, ',', 1265, 61, 1265, 62),
woosh.Token(woosh.STRING, '"utf-8"', 1265, 63, 1265, 70),
woosh.Token(woosh.OP, ',', 1265, 70, 1265, 71),
woosh.Token(woosh.NAME, 'tarfile', 1266, 20, 1266, 27),
woosh.Token(woosh.OP, '.', 1266, 27, 1266, 28),
woosh.Token(woosh.NAME, 'errors', 1266, 28, 1266, 34),
woosh.Token(woosh.OP, ')', 1266, 34, 1266, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 1266, 35, 1267, 0),
woosh.Token(woosh.NAME, 'if', 1267, 12, 1267, 14),
woosh.Token(woosh.NAME, 'keyword', 1267, 15, 1267, 22),
woosh.Token(woosh.NAME, 'in', 1267, 23, 1267, 25),
woosh.Token(woosh.NAME, 'PAX_NAME_FIELDS', 1267, 26, 1267, 41),
woosh.Token(woosh.OP, ':', 1267, 41, 1267, 42),
woosh.Token(woosh.NEWLINE, '\r\n', 1267, 42, 1268, 0),
woosh.Token(woosh.INDENT, ' ', 1268, 0, 1268, 16),
woosh.Token(woosh.NAME, 'value', 1268, 16, 1268, 21),
woosh.Token(woosh.OP, '=', 1268, 22, 1268, 23),
woosh.Token(woosh.NAME, 'self', 1268, 24, 1268, 28),
woosh.Token(woosh.OP, '.', 1268, 28, 1268, 29),
woosh.Token(woosh.NAME, '_decode_pax_field', 1268, 29, 1268, 46),
woosh.Token(woosh.OP, '(', 1268, 46, 1268, 47),
woosh.Token(woosh.NAME, 'value', 1268, 47, 1268, 52),
woosh.Token(woosh.OP, ',', 1268, 52, 1268, 53),
woosh.Token(woosh.NAME, 'encoding', 1268, 54, 1268, 62),
woosh.Token(woosh.OP, ',', 1268, 62, 1268, 63),
woosh.Token(woosh.NAME, 'tarfile', 1268, 64, 1268, 71),
woosh.Token(woosh.OP, '.', 1268, 71, 1268, 72),
woosh.Token(woosh.NAME, 'encoding', 1268, 72, 1268, 80),
woosh.Token(woosh.OP, ',', 1268, 80, 1268, 81),
woosh.Token(woosh.NAME, 'tarfile', 1269, 24, 1269, 31),
woosh.Token(woosh.OP, '.', 1269, 31, 1269, 32),
woosh.Token(woosh.NAME, 'errors', 1269, 32, 1269, 38),
woosh.Token(woosh.OP, ')', 1269, 38, 1269, 39),
woosh.Token(woosh.NEWLINE, '\r\n', 1269, 39, 1270, 0),
woosh.Token(woosh.DEDENT, ' ', 1270, 0, 1270, 12),
woosh.Token(woosh.NAME, 'else', 1270, 12, 1270, 16),
woosh.Token(woosh.OP, ':', 1270, 16, 1270, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 1270, 17, 1271, 0),
woosh.Token(woosh.INDENT, ' ', 1271, 0, 1271, 16),
woosh.Token(woosh.NAME, 'value', 1271, 16, 1271, 21),
woosh.Token(woosh.OP, '=', 1271, 22, 1271, 23),
woosh.Token(woosh.NAME, 'self', 1271, 24, 1271, 28),
woosh.Token(woosh.OP, '.', 1271, 28, 1271, 29),
woosh.Token(woosh.NAME, '_decode_pax_field', 1271, 29, 1271, 46),
woosh.Token(woosh.OP, '(', 1271, 46, 1271, 47),
woosh.Token(woosh.NAME, 'value', 1271, 47, 1271, 52),
woosh.Token(woosh.OP, ',', 1271, 52, 1271, 53),
woosh.Token(woosh.STRING, '"utf-8"', 1271, 54, 1271, 61),
woosh.Token(woosh.OP, ',', 1271, 61, 1271, 62),
woosh.Token(woosh.STRING, '"utf-8"', 1271, 63, 1271, 70),
woosh.Token(woosh.OP, ',', 1271, 70, 1271, 71),
woosh.Token(woosh.NAME, 'tarfile', 1272, 24, 1272, 31),
woosh.Token(woosh.OP, '.', 1272, 31, 1272, 32),
woosh.Token(woosh.NAME, 'errors', 1272, 32, 1272, 38),
woosh.Token(woosh.OP, ')', 1272, 38, 1272, 39),
woosh.Token(woosh.NEWLINE, '\r\n', 1272, 39, 1273, 0),
woosh.Token(woosh.DEDENT, ' ', 1274, 0, 1274, 12),
woosh.Token(woosh.NAME, 'pax_headers', 1274, 12, 1274, 23),
woosh.Token(woosh.OP, '[', 1274, 23, 1274, 24),
woosh.Token(woosh.NAME, 'keyword', 1274, 24, 1274, 31),
woosh.Token(woosh.OP, ']', 1274, 31, 1274, 32),
woosh.Token(woosh.OP, '=', 1274, 33, 1274, 34),
woosh.Token(woosh.NAME, 'value', 1274, 35, 1274, 40),
woosh.Token(woosh.NEWLINE, '\r\n', 1274, 40, 1275, 0),
woosh.Token(woosh.NAME, 'pos', 1275, 12, 1275, 15),
woosh.Token(woosh.OP, '+=', 1275, 16, 1275, 18),
woosh.Token(woosh.NAME, 'length', 1275, 19, 1275, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 1275, 25, 1276, 0),
woosh.Token(woosh.COMMENT, '# Fetch the next header.', 1277, 8, 1277, 32),
woosh.Token(woosh.DEDENT, ' ', 1278, 0, 1278, 8),
woosh.Token(woosh.NAME, 'try', 1278, 8, 1278, 11),
woosh.Token(woosh.OP, ':', 1278, 11, 1278, 12),
woosh.Token(woosh.NEWLINE, '\r\n', 1278, 12, 1279, 0),
woosh.Token(woosh.INDENT, ' ', 1279, 0, 1279, 12),
woosh.Token(woosh.NAME, 'next', 1279, 12, 1279, 16),
woosh.Token(woosh.OP, '=', 1279, 17, 1279, 18),
woosh.Token(woosh.NAME, 'self', 1279, 19, 1279, 23),
woosh.Token(woosh.OP, '.', 1279, 23, 1279, 24),
woosh.Token(woosh.NAME, 'fromtarfile', 1279, 24, 1279, 35),
woosh.Token(woosh.OP, '(', 1279, 35, 1279, 36),
woosh.Token(woosh.NAME, 'tarfile', 1279, 36, 1279, 43),
woosh.Token(woosh.OP, ')', 1279, 43, 1279, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 1279, 44, 1280, 0),
woosh.Token(woosh.DEDENT, ' ', 1280, 0, 1280, 8),
woosh.Token(woosh.NAME, 'except', 1280, 8, 1280, 14),
woosh.Token(woosh.NAME, 'HeaderError', 1280, 15, 1280, 26),
woosh.Token(woosh.OP, ':', 1280, 26, 1280, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 1280, 27, 1281, 0),
woosh.Token(woosh.INDENT, ' ', 1281, 0, 1281, 12),
woosh.Token(woosh.NAME, 'raise', 1281, 12, 1281, 17),
woosh.Token(woosh.NAME, 'SubsequentHeaderError', 1281, 18, 1281, 39),
woosh.Token(woosh.OP, '(', 1281, 39, 1281, 40),
woosh.Token(woosh.STRING, '"missing or bad subsequent header"', 1281, 40, 1281, 74),
woosh.Token(woosh.OP, ')', 1281, 74, 1281, 75),
woosh.Token(woosh.NEWLINE, '\r\n', 1281, 75, 1282, 0),
woosh.Token(woosh.COMMENT, '# Process GNU sparse information.', 1283, 8, 1283, 41),
woosh.Token(woosh.DEDENT, ' ', 1284, 0, 1284, 8),
woosh.Token(woosh.NAME, 'if', 1284, 8, 1284, 10),
woosh.Token(woosh.STRING, '"GNU.sparse.map"', 1284, 11, 1284, 27),
woosh.Token(woosh.NAME, 'in', 1284, 28, 1284, 30),
woosh.Token(woosh.NAME, 'pax_headers', 1284, 31, 1284, 42),
woosh.Token(woosh.OP, ':', 1284, 42, 1284, 43),
woosh.Token(woosh.NEWLINE, '\r\n', 1284, 43, 1285, 0),
woosh.Token(woosh.COMMENT, '# GNU extended sparse format version 0.1.', 1285, 12, 1285, 53),
woosh.Token(woosh.INDENT, ' ', 1286, 0, 1286, 12),
woosh.Token(woosh.NAME, 'self', 1286, 12, 1286, 16),
woosh.Token(woosh.OP, '.', 1286, 16, 1286, 17),
woosh.Token(woosh.NAME, '_proc_gnusparse_01', 1286, 17, 1286, 35),
woosh.Token(woosh.OP, '(', 1286, 35, 1286, 36),
woosh.Token(woosh.NAME, 'next', 1286, 36, 1286, 40),
woosh.Token(woosh.OP, ',', 1286, 40, 1286, 41),
woosh.Token(woosh.NAME, 'pax_headers', 1286, 42, 1286, 53),
woosh.Token(woosh.OP, ')', 1286, 53, 1286, 54),
woosh.Token(woosh.NEWLINE, '\r\n', 1286, 54, 1287, 0),
woosh.Token(woosh.DEDENT, ' ', 1288, 0, 1288, 8),
woosh.Token(woosh.NAME, 'elif', 1288, 8, 1288, 12),
woosh.Token(woosh.STRING, '"GNU.sparse.size"', 1288, 13, 1288, 30),
woosh.Token(woosh.NAME, 'in', 1288, 31, 1288, 33),
woosh.Token(woosh.NAME, 'pax_headers', 1288, 34, 1288, 45),
woosh.Token(woosh.OP, ':', 1288, 45, 1288, 46),
woosh.Token(woosh.NEWLINE, '\r\n', 1288, 46, 1289, 0),
woosh.Token(woosh.COMMENT, '# GNU extended sparse format version 0.0.', 1289, 12, 1289, 53),
woosh.Token(woosh.INDENT, ' ', 1290, 0, 1290, 12),
woosh.Token(woosh.NAME, 'self', 1290, 12, 1290, 16),
woosh.Token(woosh.OP, '.', 1290, 16, 1290, 17),
woosh.Token(woosh.NAME, '_proc_gnusparse_00', 1290, 17, 1290, 35),
woosh.Token(woosh.OP, '(', 1290, 35, 1290, 36),
woosh.Token(woosh.NAME, 'next', 1290, 36, 1290, 40),
woosh.Token(woosh.OP, ',', 1290, 40, 1290, 41),
woosh.Token(woosh.NAME, 'pax_headers', 1290, 42, 1290, 53),
woosh.Token(woosh.OP, ',', 1290, 53, 1290, 54),
woosh.Token(woosh.NAME, 'buf', 1290, 55, 1290, 58),
woosh.Token(woosh.OP, ')', 1290, 58, 1290, 59),
woosh.Token(woosh.NEWLINE, '\r\n', 1290, 59, 1291, 0),
woosh.Token(woosh.DEDENT, ' ', 1292, 0, 1292, 8),
woosh.Token(woosh.NAME, 'elif', 1292, 8, 1292, 12),
woosh.Token(woosh.NAME, 'pax_headers', 1292, 13, 1292, 24),
woosh.Token(woosh.OP, '.', 1292, 24, 1292, 25),
woosh.Token(woosh.NAME, 'get', 1292, 25, 1292, 28),
woosh.Token(woosh.OP, '(', 1292, 28, 1292, 29),
woosh.Token(woosh.STRING, '"GNU.sparse.major"', 1292, 29, 1292, 47),
woosh.Token(woosh.OP, ')', 1292, 47, 1292, 48),
woosh.Token(woosh.OP, '==', 1292, 49, 1292, 51),
woosh.Token(woosh.STRING, '"1"', 1292, 52, 1292, 55),
woosh.Token(woosh.NAME, 'and', 1292, 56, 1292, 59),
woosh.Token(woosh.NAME, 'pax_headers', 1292, 60, 1292, 71),
woosh.Token(woosh.OP, '.', 1292, 71, 1292, 72),
woosh.Token(woosh.NAME, 'get', 1292, 72, 1292, 75),
woosh.Token(woosh.OP, '(', 1292, 75, 1292, 76),
woosh.Token(woosh.STRING, '"GNU.sparse.minor"', 1292, 76, 1292, 94),
woosh.Token(woosh.OP, ')', 1292, 94, 1292, 95),
woosh.Token(woosh.OP, '==', 1292, 96, 1292, 98),
woosh.Token(woosh.STRING, '"0"', 1292, 99, 1292, 102),
woosh.Token(woosh.OP, ':', 1292, 102, 1292, 103),
woosh.Token(woosh.NEWLINE, '\r\n', 1292, 103, 1293, 0),
woosh.Token(woosh.COMMENT, '# GNU extended sparse format version 1.0.', 1293, 12, 1293, 53),
woosh.Token(woosh.INDENT, ' ', 1294, 0, 1294, 12),
woosh.Token(woosh.NAME, 'self', 1294, 12, 1294, 16),
woosh.Token(woosh.OP, '.', 1294, 16, 1294, 17),
woosh.Token(woosh.NAME, '_proc_gnusparse_10', 1294, 17, 1294, 35),
woosh.Token(woosh.OP, '(', 1294, 35, 1294, 36),
woosh.Token(woosh.NAME, 'next', 1294, 36, 1294, 40),
woosh.Token(woosh.OP, ',', 1294, 40, 1294, 41),
woosh.Token(woosh.NAME, 'pax_headers', 1294, 42, 1294, 53),
woosh.Token(woosh.OP, ',', 1294, 53, 1294, 54),
woosh.Token(woosh.NAME, 'tarfile', 1294, 55, 1294, 62),
woosh.Token(woosh.OP, ')', 1294, 62, 1294, 63),
woosh.Token(woosh.NEWLINE, '\r\n', 1294, 63, 1295, 0),
woosh.Token(woosh.DEDENT, ' ', 1296, 0, 1296, 8),
woosh.Token(woosh.NAME, 'if', 1296, 8, 1296, 10),
woosh.Token(woosh.NAME, 'self', 1296, 11, 1296, 15),
woosh.Token(woosh.OP, '.', 1296, 15, 1296, 16),
woosh.Token(woosh.NAME, 'type', 1296, 16, 1296, 20),
woosh.Token(woosh.NAME, 'in', 1296, 21, 1296, 23),
woosh.Token(woosh.OP, '(', 1296, 24, 1296, 25),
woosh.Token(woosh.NAME, 'XHDTYPE', 1296, 25, 1296, 32),
woosh.Token(woosh.OP, ',', 1296, 32, 1296, 33),
woosh.Token(woosh.NAME, 'SOLARIS_XHDTYPE', 1296, 34, 1296, 49),
woosh.Token(woosh.OP, ')', 1296, 49, 1296, 50),
woosh.Token(woosh.OP, ':', 1296, 50, 1296, 51),
woosh.Token(woosh.NEWLINE, '\r\n', 1296, 51, 1297, 0),
woosh.Token(woosh.COMMENT, '# Patch the TarInfo object with the extended header info.', 1297, 12, 1297, 69),
woosh.Token(woosh.INDENT, ' ', 1298, 0, 1298, 12),
woosh.Token(woosh.NAME, 'next', 1298, 12, 1298, 16),
woosh.Token(woosh.OP, '.', 1298, 16, 1298, 17),
woosh.Token(woosh.NAME, '_apply_pax_info', 1298, 17, 1298, 32),
woosh.Token(woosh.OP, '(', 1298, 32, 1298, 33),
woosh.Token(woosh.NAME, 'pax_headers', 1298, 33, 1298, 44),
woosh.Token(woosh.OP, ',', 1298, 44, 1298, 45),
woosh.Token(woosh.NAME, 'tarfile', 1298, 46, 1298, 53),
woosh.Token(woosh.OP, '.', 1298, 53, 1298, 54),
woosh.Token(woosh.NAME, 'encoding', 1298, 54, 1298, 62),
woosh.Token(woosh.OP, ',', 1298, 62, 1298, 63),
woosh.Token(woosh.NAME, 'tarfile', 1298, 64, 1298, 71),
woosh.Token(woosh.OP, '.', 1298, 71, 1298, 72),
woosh.Token(woosh.NAME, 'errors', 1298, 72, 1298, 78),
woosh.Token(woosh.OP, ')', 1298, 78, 1298, 79),
woosh.Token(woosh.NEWLINE, '\r\n', 1298, 79, 1299, 0),
woosh.Token(woosh.NAME, 'next', 1299, 12, 1299, 16),
woosh.Token(woosh.OP, '.', 1299, 16, 1299, 17),
woosh.Token(woosh.NAME, 'offset', 1299, 17, 1299, 23),
woosh.Token(woosh.OP, '=', 1299, 24, 1299, 25),
woosh.Token(woosh.NAME, 'self', 1299, 26, 1299, 30),
woosh.Token(woosh.OP, '.', 1299, 30, 1299, 31),
woosh.Token(woosh.NAME, 'offset', 1299, 31, 1299, 37),
woosh.Token(woosh.NEWLINE, '\r\n', 1299, 37, 1300, 0),
woosh.Token(woosh.NAME, 'if', 1301, 12, 1301, 14),
woosh.Token(woosh.STRING, '"size"', 1301, 15, 1301, 21),
woosh.Token(woosh.NAME, 'in', 1301, 22, 1301, 24),
woosh.Token(woosh.NAME, 'pax_headers', 1301, 25, 1301, 36),
woosh.Token(woosh.OP, ':', 1301, 36, 1301, 37),
woosh.Token(woosh.NEWLINE, '\r\n', 1301, 37, 1302, 0),
woosh.Token(woosh.COMMENT, '# If the extended header replaces the size field,', 1302, 16, 1302, 65),
woosh.Token(woosh.COMMENT, '# we need to recalculate the offset where the next', 1303, 16, 1303, 66),
woosh.Token(woosh.COMMENT, '# header starts.', 1304, 16, 1304, 32),
woosh.Token(woosh.INDENT, ' ', 1305, 0, 1305, 16),
woosh.Token(woosh.NAME, 'offset', 1305, 16, 1305, 22),
woosh.Token(woosh.OP, '=', 1305, 23, 1305, 24),
woosh.Token(woosh.NAME, 'next', 1305, 25, 1305, 29),
woosh.Token(woosh.OP, '.', 1305, 29, 1305, 30),
woosh.Token(woosh.NAME, 'offset_data', 1305, 30, 1305, 41),
woosh.Token(woosh.NEWLINE, '\r\n', 1305, 41, 1306, 0),
woosh.Token(woosh.NAME, 'if', 1306, 16, 1306, 18),
woosh.Token(woosh.NAME, 'next', 1306, 19, 1306, 23),
woosh.Token(woosh.OP, '.', 1306, 23, 1306, 24),
woosh.Token(woosh.NAME, 'isreg', 1306, 24, 1306, 29),
woosh.Token(woosh.OP, '(', 1306, 29, 1306, 30),
woosh.Token(woosh.OP, ')', 1306, 30, 1306, 31),
woosh.Token(woosh.NAME, 'or', 1306, 32, 1306, 34),
woosh.Token(woosh.NAME, 'next', 1306, 35, 1306, 39),
woosh.Token(woosh.OP, '.', 1306, 39, 1306, 40),
woosh.Token(woosh.NAME, 'type', 1306, 40, 1306, 44),
woosh.Token(woosh.NAME, 'not', 1306, 45, 1306, 48),
woosh.Token(woosh.NAME, 'in', 1306, 49, 1306, 51),
woosh.Token(woosh.NAME, 'SUPPORTED_TYPES', 1306, 52, 1306, 67),
woosh.Token(woosh.OP, ':', 1306, 67, 1306, 68),
woosh.Token(woosh.NEWLINE, '\r\n', 1306, 68, 1307, 0),
woosh.Token(woosh.INDENT, ' ', 1307, 0, 1307, 20),
woosh.Token(woosh.NAME, 'offset', 1307, 20, 1307, 26),
woosh.Token(woosh.OP, '+=', 1307, 27, 1307, 29),
woosh.Token(woosh.NAME, 'next', 1307, 30, 1307, 34),
woosh.Token(woosh.OP, '.', 1307, 34, 1307, 35),
woosh.Token(woosh.NAME, '_block', 1307, 35, 1307, 41),
woosh.Token(woosh.OP, '(', 1307, 41, 1307, 42),
woosh.Token(woosh.NAME, 'next', 1307, 42, 1307, 46),
woosh.Token(woosh.OP, '.', 1307, 46, 1307, 47),
woosh.Token(woosh.NAME, 'size', 1307, 47, 1307, 51),
woosh.Token(woosh.OP, ')', 1307, 51, 1307, 52),
woosh.Token(woosh.NEWLINE, '\r\n', 1307, 52, 1308, 0),
woosh.Token(woosh.DEDENT, ' ', 1308, 0, 1308, 16),
woosh.Token(woosh.NAME, 'tarfile', 1308, 16, 1308, 23),
woosh.Token(woosh.OP, '.', 1308, 23, 1308, 24),
woosh.Token(woosh.NAME, 'offset', 1308, 24, 1308, 30),
woosh.Token(woosh.OP, '=', 1308, 31, 1308, 32),
woosh.Token(woosh.NAME, 'offset', 1308, 33, 1308, 39),
woosh.Token(woosh.NEWLINE, '\r\n', 1308, 39, 1309, 0),
woosh.Token(woosh.DEDENT, ' ', 1310, 0, 1310, 8),
woosh.Token(woosh.DEDENT, '', 1310, 8, 1310, 8),
woosh.Token(woosh.NAME, 'return', 1310, 8, 1310, 14),
woosh.Token(woosh.NAME, 'next', 1310, 15, 1310, 19),
woosh.Token(woosh.NEWLINE, '\r\n', 1310, 19, 1311, 0),
woosh.Token(woosh.DEDENT, ' ', 1312, 0, 1312, 4),
woosh.Token(woosh.NAME, 'def', 1312, 4, 1312, 7),
woosh.Token(woosh.NAME, '_proc_gnusparse_00', 1312, 8, 1312, 26),
woosh.Token(woosh.OP, '(', 1312, 26, 1312, 27),
woosh.Token(woosh.NAME, 'self', 1312, 27, 1312, 31),
woosh.Token(woosh.OP, ',', 1312, 31, 1312, 32),
woosh.Token(woosh.NAME, 'next', 1312, 33, 1312, 37),
woosh.Token(woosh.OP, ',', 1312, 37, 1312, 38),
woosh.Token(woosh.NAME, 'pax_headers', 1312, 39, 1312, 50),
woosh.Token(woosh.OP, ',', 1312, 50, 1312, 51),
woosh.Token(woosh.NAME, 'buf', 1312, 52, 1312, 55),
woosh.Token(woosh.OP, ')', 1312, 55, 1312, 56),
woosh.Token(woosh.OP, ':', 1312, 56, 1312, 57),
woosh.Token(woosh.NEWLINE, '\r\n', 1312, 57, 1313, 0),
woosh.Token(woosh.INDENT, ' ', 1313, 0, 1313, 8),
woosh.Token(woosh.STRING, '"""Process a GNU tar extended sparse header, version 0.0.\r\n """', 1313, 8, 1314, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 1314, 11, 1315, 0),
woosh.Token(woosh.NAME, 'offsets', 1315, 8, 1315, 15),
woosh.Token(woosh.OP, '=', 1315, 16, 1315, 17),
woosh.Token(woosh.OP, '[', 1315, 18, 1315, 19),
woosh.Token(woosh.OP, ']', 1315, 19, 1315, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 1315, 20, 1316, 0),
woosh.Token(woosh.NAME, 'for', 1316, 8, 1316, 11),
woosh.Token(woosh.NAME, 'match', 1316, 12, 1316, 17),
woosh.Token(woosh.NAME, 'in', 1316, 18, 1316, 20),
woosh.Token(woosh.NAME, 're', 1316, 21, 1316, 23),
woosh.Token(woosh.OP, '.', 1316, 23, 1316, 24),
woosh.Token(woosh.NAME, 'finditer', 1316, 24, 1316, 32),
woosh.Token(woosh.OP, '(', 1316, 32, 1316, 33),
woosh.Token(woosh.STRING, 'br"\\d+ GNU.sparse.offset=(\\d+)\\n"', 1316, 33, 1316, 66),
woosh.Token(woosh.OP, ',', 1316, 66, 1316, 67),
woosh.Token(woosh.NAME, 'buf', 1316, 68, 1316, 71),
woosh.Token(woosh.OP, ')', 1316, 71, 1316, 72),
woosh.Token(woosh.OP, ':', 1316, 72, 1316, 73),
woosh.Token(woosh.NEWLINE, '\r\n', 1316, 73, 1317, 0),
woosh.Token(woosh.INDENT, ' ', 1317, 0, 1317, 12),
woosh.Token(woosh.NAME, 'offsets', 1317, 12, 1317, 19),
woosh.Token(woosh.OP, '.', 1317, 19, 1317, 20),
woosh.Token(woosh.NAME, 'append', 1317, 20, 1317, 26),
woosh.Token(woosh.OP, '(', 1317, 26, 1317, 27),
woosh.Token(woosh.NAME, 'int', 1317, 27, 1317, 30),
woosh.Token(woosh.OP, '(', 1317, 30, 1317, 31),
woosh.Token(woosh.NAME, 'match', 1317, 31, 1317, 36),
woosh.Token(woosh.OP, '.', 1317, 36, 1317, 37),
woosh.Token(woosh.NAME, 'group', 1317, 37, 1317, 42),
woosh.Token(woosh.OP, '(', 1317, 42, 1317, 43),
woosh.Token(woosh.NUMBER, '1', 1317, 43, 1317, 44),
woosh.Token(woosh.OP, ')', 1317, 44, 1317, 45),
woosh.Token(woosh.OP, ')', 1317, 45, 1317, 46),
woosh.Token(woosh.OP, ')', 1317, 46, 1317, 47),
woosh.Token(woosh.NEWLINE, '\r\n', 1317, 47, 1318, 0),
woosh.Token(woosh.DEDENT, ' ', 1318, 0, 1318, 8),
woosh.Token(woosh.NAME, 'numbytes', 1318, 8, 1318, 16),
woosh.Token(woosh.OP, '=', 1318, 17, 1318, 18),
woosh.Token(woosh.OP, '[', 1318, 19, 1318, 20),
woosh.Token(woosh.OP, ']', 1318, 20, 1318, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 1318, 21, 1319, 0),
woosh.Token(woosh.NAME, 'for', 1319, 8, 1319, 11),
woosh.Token(woosh.NAME, 'match', 1319, 12, 1319, 17),
woosh.Token(woosh.NAME, 'in', 1319, 18, 1319, 20),
woosh.Token(woosh.NAME, 're', 1319, 21, 1319, 23),
woosh.Token(woosh.OP, '.', 1319, 23, 1319, 24),
woosh.Token(woosh.NAME, 'finditer', 1319, 24, 1319, 32),
woosh.Token(woosh.OP, '(', 1319, 32, 1319, 33),
woosh.Token(woosh.STRING, 'br"\\d+ GNU.sparse.numbytes=(\\d+)\\n"', 1319, 33, 1319, 68),
woosh.Token(woosh.OP, ',', 1319, 68, 1319, 69),
woosh.Token(woosh.NAME, 'buf', 1319, 70, 1319, 73),
woosh.Token(woosh.OP, ')', 1319, 73, 1319, 74),
woosh.Token(woosh.OP, ':', 1319, 74, 1319, 75),
woosh.Token(woosh.NEWLINE, '\r\n', 1319, 75, 1320, 0),
woosh.Token(woosh.INDENT, ' ', 1320, 0, 1320, 12),
woosh.Token(woosh.NAME, 'numbytes', 1320, 12, 1320, 20),
woosh.Token(woosh.OP, '.', 1320, 20, 1320, 21),
woosh.Token(woosh.NAME, 'append', 1320, 21, 1320, 27),
woosh.Token(woosh.OP, '(', 1320, 27, 1320, 28),
woosh.Token(woosh.NAME, 'int', 1320, 28, 1320, 31),
woosh.Token(woosh.OP, '(', 1320, 31, 1320, 32),
woosh.Token(woosh.NAME, 'match', 1320, 32, 1320, 37),
woosh.Token(woosh.OP, '.', 1320, 37, 1320, 38),
woosh.Token(woosh.NAME, 'group', 1320, 38, 1320, 43),
woosh.Token(woosh.OP, '(', 1320, 43, 1320, 44),
woosh.Token(woosh.NUMBER, '1', 1320, 44, 1320, 45),
woosh.Token(woosh.OP, ')', 1320, 45, 1320, 46),
woosh.Token(woosh.OP, ')', 1320, 46, 1320, 47),
woosh.Token(woosh.OP, ')', 1320, 47, 1320, 48),
woosh.Token(woosh.NEWLINE, '\r\n', 1320, 48, 1321, 0),
woosh.Token(woosh.DEDENT, ' ', 1321, 0, 1321, 8),
woosh.Token(woosh.NAME, 'next', 1321, 8, 1321, 12),
woosh.Token(woosh.OP, '.', 1321, 12, 1321, 13),
woosh.Token(woosh.NAME, 'sparse', 1321, 13, 1321, 19),
woosh.Token(woosh.OP, '=', 1321, 20, 1321, 21),
woosh.Token(woosh.NAME, 'list', 1321, 22, 1321, 26),
woosh.Token(woosh.OP, '(', 1321, 26, 1321, 27),
woosh.Token(woosh.NAME, 'zip', 1321, 27, 1321, 30),
woosh.Token(woosh.OP, '(', 1321, 30, 1321, 31),
woosh.Token(woosh.NAME, 'offsets', 1321, 31, 1321, 38),
woosh.Token(woosh.OP, ',', 1321, 38, 1321, 39),
woosh.Token(woosh.NAME, 'numbytes', 1321, 40, 1321, 48),
woosh.Token(woosh.OP, ')', 1321, 48, 1321, 49),
woosh.Token(woosh.OP, ')', 1321, 49, 1321, 50),
woosh.Token(woosh.NEWLINE, '\r\n', 1321, 50, 1322, 0),
woosh.Token(woosh.DEDENT, ' ', 1323, 0, 1323, 4),
woosh.Token(woosh.NAME, 'def', 1323, 4, 1323, 7),
woosh.Token(woosh.NAME, '_proc_gnusparse_01', 1323, 8, 1323, 26),
woosh.Token(woosh.OP, '(', 1323, 26, 1323, 27),
woosh.Token(woosh.NAME, 'self', 1323, 27, 1323, 31),
woosh.Token(woosh.OP, ',', 1323, 31, 1323, 32),
woosh.Token(woosh.NAME, 'next', 1323, 33, 1323, 37),
woosh.Token(woosh.OP, ',', 1323, 37, 1323, 38),
woosh.Token(woosh.NAME, 'pax_headers', 1323, 39, 1323, 50),
woosh.Token(woosh.OP, ')', 1323, 50, 1323, 51),
woosh.Token(woosh.OP, ':', 1323, 51, 1323, 52),
woosh.Token(woosh.NEWLINE, '\r\n', 1323, 52, 1324, 0),
woosh.Token(woosh.INDENT, ' ', 1324, 0, 1324, 8),
woosh.Token(woosh.STRING, '"""Process a GNU tar extended sparse header, version 0.1.\r\n """', 1324, 8, 1325, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 1325, 11, 1326, 0),
woosh.Token(woosh.NAME, 'sparse', 1326, 8, 1326, 14),
woosh.Token(woosh.OP, '=', 1326, 15, 1326, 16),
woosh.Token(woosh.OP, '[', 1326, 17, 1326, 18),
woosh.Token(woosh.NAME, 'int', 1326, 18, 1326, 21),
woosh.Token(woosh.OP, '(', 1326, 21, 1326, 22),
woosh.Token(woosh.NAME, 'x', 1326, 22, 1326, 23),
woosh.Token(woosh.OP, ')', 1326, 23, 1326, 24),
woosh.Token(woosh.NAME, 'for', 1326, 25, 1326, 28),
woosh.Token(woosh.NAME, 'x', 1326, 29, 1326, 30),
woosh.Token(woosh.NAME, 'in', 1326, 31, 1326, 33),
woosh.Token(woosh.NAME, 'pax_headers', 1326, 34, 1326, 45),
woosh.Token(woosh.OP, '[', 1326, 45, 1326, 46),
woosh.Token(woosh.STRING, '"GNU.sparse.map"', 1326, 46, 1326, 62),
woosh.Token(woosh.OP, ']', 1326, 62, 1326, 63),
woosh.Token(woosh.OP, '.', 1326, 63, 1326, 64),
woosh.Token(woosh.NAME, 'split', 1326, 64, 1326, 69),
woosh.Token(woosh.OP, '(', 1326, 69, 1326, 70),
woosh.Token(woosh.STRING, '","', 1326, 70, 1326, 73),
woosh.Token(woosh.OP, ')', 1326, 73, 1326, 74),
woosh.Token(woosh.OP, ']', 1326, 74, 1326, 75),
woosh.Token(woosh.NEWLINE, '\r\n', 1326, 75, 1327, 0),
woosh.Token(woosh.NAME, 'next', 1327, 8, 1327, 12),
woosh.Token(woosh.OP, '.', 1327, 12, 1327, 13),
woosh.Token(woosh.NAME, 'sparse', 1327, 13, 1327, 19),
woosh.Token(woosh.OP, '=', 1327, 20, 1327, 21),
woosh.Token(woosh.NAME, 'list', 1327, 22, 1327, 26),
woosh.Token(woosh.OP, '(', 1327, 26, 1327, 27),
woosh.Token(woosh.NAME, 'zip', 1327, 27, 1327, 30),
woosh.Token(woosh.OP, '(', 1327, 30, 1327, 31),
woosh.Token(woosh.NAME, 'sparse', 1327, 31, 1327, 37),
woosh.Token(woosh.OP, '[', 1327, 37, 1327, 38),
woosh.Token(woosh.OP, ':', 1327, 38, 1327, 39),
woosh.Token(woosh.OP, ':', 1327, 39, 1327, 40),
woosh.Token(woosh.NUMBER, '2', 1327, 40, 1327, 41),
woosh.Token(woosh.OP, ']', 1327, 41, 1327, 42),
woosh.Token(woosh.OP, ',', 1327, 42, 1327, 43),
woosh.Token(woosh.NAME, 'sparse', 1327, 44, 1327, 50),
woosh.Token(woosh.OP, '[', 1327, 50, 1327, 51),
woosh.Token(woosh.NUMBER, '1', 1327, 51, 1327, 52),
woosh.Token(woosh.OP, ':', 1327, 52, 1327, 53),
woosh.Token(woosh.OP, ':', 1327, 53, 1327, 54),
woosh.Token(woosh.NUMBER, '2', 1327, 54, 1327, 55),
woosh.Token(woosh.OP, ']', 1327, 55, 1327, 56),
woosh.Token(woosh.OP, ')', 1327, 56, 1327, 57),
woosh.Token(woosh.OP, ')', 1327, 57, 1327, 58),
woosh.Token(woosh.NEWLINE, '\r\n', 1327, 58, 1328, 0),
woosh.Token(woosh.DEDENT, ' ', 1329, 0, 1329, 4),
woosh.Token(woosh.NAME, 'def', 1329, 4, 1329, 7),
woosh.Token(woosh.NAME, '_proc_gnusparse_10', 1329, 8, 1329, 26),
woosh.Token(woosh.OP, '(', 1329, 26, 1329, 27),
woosh.Token(woosh.NAME, 'self', 1329, 27, 1329, 31),
woosh.Token(woosh.OP, ',', 1329, 31, 1329, 32),
woosh.Token(woosh.NAME, 'next', 1329, 33, 1329, 37),
woosh.Token(woosh.OP, ',', 1329, 37, 1329, 38),
woosh.Token(woosh.NAME, 'pax_headers', 1329, 39, 1329, 50),
woosh.Token(woosh.OP, ',', 1329, 50, 1329, 51),
woosh.Token(woosh.NAME, 'tarfile', 1329, 52, 1329, 59),
woosh.Token(woosh.OP, ')', 1329, 59, 1329, 60),
woosh.Token(woosh.OP, ':', 1329, 60, 1329, 61),
woosh.Token(woosh.NEWLINE, '\r\n', 1329, 61, 1330, 0),
woosh.Token(woosh.INDENT, ' ', 1330, 0, 1330, 8),
woosh.Token(woosh.STRING, '"""Process a GNU tar extended sparse header, version 1.0.\r\n """', 1330, 8, 1331, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 1331, 11, 1332, 0),
woosh.Token(woosh.NAME, 'fields', 1332, 8, 1332, 14),
woosh.Token(woosh.OP, '=', 1332, 15, 1332, 16),
woosh.Token(woosh.NAME, 'None', 1332, 17, 1332, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 1332, 21, 1333, 0),
woosh.Token(woosh.NAME, 'sparse', 1333, 8, 1333, 14),
woosh.Token(woosh.OP, '=', 1333, 15, 1333, 16),
woosh.Token(woosh.OP, '[', 1333, 17, 1333, 18),
woosh.Token(woosh.OP, ']', 1333, 18, 1333, 19),
woosh.Token(woosh.NEWLINE, '\r\n', 1333, 19, 1334, 0),
woosh.Token(woosh.NAME, 'buf', 1334, 8, 1334, 11),
woosh.Token(woosh.OP, '=', 1334, 12, 1334, 13),
woosh.Token(woosh.NAME, 'tarfile', 1334, 14, 1334, 21),
woosh.Token(woosh.OP, '.', 1334, 21, 1334, 22),
woosh.Token(woosh.NAME, 'fileobj', 1334, 22, 1334, 29),
woosh.Token(woosh.OP, '.', 1334, 29, 1334, 30),
woosh.Token(woosh.NAME, 'read', 1334, 30, 1334, 34),
woosh.Token(woosh.OP, '(', 1334, 34, 1334, 35),
woosh.Token(woosh.NAME, 'BLOCKSIZE', 1334, 35, 1334, 44),
woosh.Token(woosh.OP, ')', 1334, 44, 1334, 45),
woosh.Token(woosh.NEWLINE, '\r\n', 1334, 45, 1335, 0),
woosh.Token(woosh.NAME, 'fields', 1335, 8, 1335, 14),
woosh.Token(woosh.OP, ',', 1335, 14, 1335, 15),
woosh.Token(woosh.NAME, 'buf', 1335, 16, 1335, 19),
woosh.Token(woosh.OP, '=', 1335, 20, 1335, 21),
woosh.Token(woosh.NAME, 'buf', 1335, 22, 1335, 25),
woosh.Token(woosh.OP, '.', 1335, 25, 1335, 26),
woosh.Token(woosh.NAME, 'split', 1335, 26, 1335, 31),
woosh.Token(woosh.OP, '(', 1335, 31, 1335, 32),
woosh.Token(woosh.STRING, 'b"\\n"', 1335, 32, 1335, 37),
woosh.Token(woosh.OP, ',', 1335, 37, 1335, 38),
woosh.Token(woosh.NUMBER, '1', 1335, 39, 1335, 40),
woosh.Token(woosh.OP, ')', 1335, 40, 1335, 41),
woosh.Token(woosh.NEWLINE, '\r\n', 1335, 41, 1336, 0),
woosh.Token(woosh.NAME, 'fields', 1336, 8, 1336, 14),
woosh.Token(woosh.OP, '=', 1336, 15, 1336, 16),
woosh.Token(woosh.NAME, 'int', 1336, 17, 1336, 20),
woosh.Token(woosh.OP, '(', 1336, 20, 1336, 21),
woosh.Token(woosh.NAME, 'fields', 1336, 21, 1336, 27),
woosh.Token(woosh.OP, ')', 1336, 27, 1336, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 1336, 28, 1337, 0),
woosh.Token(woosh.NAME, 'while', 1337, 8, 1337, 13),
woosh.Token(woosh.NAME, 'len', 1337, 14, 1337, 17),
woosh.Token(woosh.OP, '(', 1337, 17, 1337, 18),
woosh.Token(woosh.NAME, 'sparse', 1337, 18, 1337, 24),
woosh.Token(woosh.OP, ')', 1337, 24, 1337, 25),
woosh.Token(woosh.OP, '<', 1337, 26, 1337, 27),
woosh.Token(woosh.NAME, 'fields', 1337, 28, 1337, 34),
woosh.Token(woosh.OP, '*', 1337, 35, 1337, 36),
woosh.Token(woosh.NUMBER, '2', 1337, 37, 1337, 38),
woosh.Token(woosh.OP, ':', 1337, 38, 1337, 39),
woosh.Token(woosh.NEWLINE, '\r\n', 1337, 39, 1338, 0),
woosh.Token(woosh.INDENT, ' ', 1338, 0, 1338, 12),
woosh.Token(woosh.NAME, 'if', 1338, 12, 1338, 14),
woosh.Token(woosh.STRING, 'b"\\n"', 1338, 15, 1338, 20),
woosh.Token(woosh.NAME, 'not', 1338, 21, 1338, 24),
woosh.Token(woosh.NAME, 'in', 1338, 25, 1338, 27),
woosh.Token(woosh.NAME, 'buf', 1338, 28, 1338, 31),
woosh.Token(woosh.OP, ':', 1338, 31, 1338, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 1338, 32, 1339, 0),
woosh.Token(woosh.INDENT, ' ', 1339, 0, 1339, 16),
woosh.Token(woosh.NAME, 'buf', 1339, 16, 1339, 19),
woosh.Token(woosh.OP, '+=', 1339, 20, 1339, 22),
woosh.Token(woosh.NAME, 'tarfile', 1339, 23, 1339, 30),
woosh.Token(woosh.OP, '.', 1339, 30, 1339, 31),
woosh.Token(woosh.NAME, 'fileobj', 1339, 31, 1339, 38),
woosh.Token(woosh.OP, '.', 1339, 38, 1339, 39),
woosh.Token(woosh.NAME, 'read', 1339, 39, 1339, 43),
woosh.Token(woosh.OP, '(', 1339, 43, 1339, 44),
woosh.Token(woosh.NAME, 'BLOCKSIZE', 1339, 44, 1339, 53),
woosh.Token(woosh.OP, ')', 1339, 53, 1339, 54),
woosh.Token(woosh.NEWLINE, '\r\n', 1339, 54, 1340, 0),
woosh.Token(woosh.DEDENT, ' ', 1340, 0, 1340, 12),
woosh.Token(woosh.NAME, 'number', 1340, 12, 1340, 18),
woosh.Token(woosh.OP, ',', 1340, 18, 1340, 19),
woosh.Token(woosh.NAME, 'buf', 1340, 20, 1340, 23),
woosh.Token(woosh.OP, '=', 1340, 24, 1340, 25),
woosh.Token(woosh.NAME, 'buf', 1340, 26, 1340, 29),
woosh.Token(woosh.OP, '.', 1340, 29, 1340, 30),
woosh.Token(woosh.NAME, 'split', 1340, 30, 1340, 35),
woosh.Token(woosh.OP, '(', 1340, 35, 1340, 36),
woosh.Token(woosh.STRING, 'b"\\n"', 1340, 36, 1340, 41),
woosh.Token(woosh.OP, ',', 1340, 41, 1340, 42),
woosh.Token(woosh.NUMBER, '1', 1340, 43, 1340, 44),
woosh.Token(woosh.OP, ')', 1340, 44, 1340, 45),
woosh.Token(woosh.NEWLINE, '\r\n', 1340, 45, 1341, 0),
woosh.Token(woosh.NAME, 'sparse', 1341, 12, 1341, 18),
woosh.Token(woosh.OP, '.', 1341, 18, 1341, 19),
woosh.Token(woosh.NAME, 'append', 1341, 19, 1341, 25),
woosh.Token(woosh.OP, '(', 1341, 25, 1341, 26),
woosh.Token(woosh.NAME, 'int', 1341, 26, 1341, 29),
woosh.Token(woosh.OP, '(', 1341, 29, 1341, 30),
woosh.Token(woosh.NAME, 'number', 1341, 30, 1341, 36),
woosh.Token(woosh.OP, ')', 1341, 36, 1341, 37),
woosh.Token(woosh.OP, ')', 1341, 37, 1341, 38),
woosh.Token(woosh.NEWLINE, '\r\n', 1341, 38, 1342, 0),
woosh.Token(woosh.DEDENT, ' ', 1342, 0, 1342, 8),
woosh.Token(woosh.NAME, 'next', 1342, 8, 1342, 12),
woosh.Token(woosh.OP, '.', 1342, 12, 1342, 13),
woosh.Token(woosh.NAME, 'offset_data', 1342, 13, 1342, 24),
woosh.Token(woosh.OP, '=', 1342, 25, 1342, 26),
woosh.Token(woosh.NAME, 'tarfile', 1342, 27, 1342, 34),
woosh.Token(woosh.OP, '.', 1342, 34, 1342, 35),
woosh.Token(woosh.NAME, 'fileobj', 1342, 35, 1342, 42),
woosh.Token(woosh.OP, '.', 1342, 42, 1342, 43),
woosh.Token(woosh.NAME, 'tell', 1342, 43, 1342, 47),
woosh.Token(woosh.OP, '(', 1342, 47, 1342, 48),
woosh.Token(woosh.OP, ')', 1342, 48, 1342, 49),
woosh.Token(woosh.NEWLINE, '\r\n', 1342, 49, 1343, 0),
woosh.Token(woosh.NAME, 'next', 1343, 8, 1343, 12),
woosh.Token(woosh.OP, '.', 1343, 12, 1343, 13),
woosh.Token(woosh.NAME, 'sparse', 1343, 13, 1343, 19),
woosh.Token(woosh.OP, '=', 1343, 20, 1343, 21),
woosh.Token(woosh.NAME, 'list', 1343, 22, 1343, 26),
woosh.Token(woosh.OP, '(', 1343, 26, 1343, 27),
woosh.Token(woosh.NAME, 'zip', 1343, 27, 1343, 30),
woosh.Token(woosh.OP, '(', 1343, 30, 1343, 31),
woosh.Token(woosh.NAME, 'sparse', 1343, 31, 1343, 37),
woosh.Token(woosh.OP, '[', 1343, 37, 1343, 38),
woosh.Token(woosh.OP, ':', 1343, 38, 1343, 39),
woosh.Token(woosh.OP, ':', 1343, 39, 1343, 40),
woosh.Token(woosh.NUMBER, '2', 1343, 40, 1343, 41),
woosh.Token(woosh.OP, ']', 1343, 41, 1343, 42),
woosh.Token(woosh.OP, ',', 1343, 42, 1343, 43),
woosh.Token(woosh.NAME, 'sparse', 1343, 44, 1343, 50),
woosh.Token(woosh.OP, '[', 1343, 50, 1343, 51),
woosh.Token(woosh.NUMBER, '1', 1343, 51, 1343, 52),
woosh.Token(woosh.OP, ':', 1343, 52, 1343, 53),
woosh.Token(woosh.OP, ':', 1343, 53, 1343, 54),
woosh.Token(woosh.NUMBER, '2', 1343, 54, 1343, 55),
woosh.Token(woosh.OP, ']', 1343, 55, 1343, 56),
woosh.Token(woosh.OP, ')', 1343, 56, 1343, 57),
woosh.Token(woosh.OP, ')', 1343, 57, 1343, 58),
woosh.Token(woosh.NEWLINE, '\r\n', 1343, 58, 1344, 0),
woosh.Token(woosh.DEDENT, ' ', 1345, 0, 1345, 4),
woosh.Token(woosh.NAME, 'def', 1345, 4, 1345, 7),
woosh.Token(woosh.NAME, '_apply_pax_info', 1345, 8, 1345, 23),
woosh.Token(woosh.OP, '(', 1345, 23, 1345, 24),
woosh.Token(woosh.NAME, 'self', 1345, 24, 1345, 28),
woosh.Token(woosh.OP, ',', 1345, 28, 1345, 29),
woosh.Token(woosh.NAME, 'pax_headers', 1345, 30, 1345, 41),
woosh.Token(woosh.OP, ',', 1345, 41, 1345, 42),
woosh.Token(woosh.NAME, 'encoding', 1345, 43, 1345, 51),
woosh.Token(woosh.OP, ',', 1345, 51, 1345, 52),
woosh.Token(woosh.NAME, 'errors', 1345, 53, 1345, 59),
woosh.Token(woosh.OP, ')', 1345, 59, 1345, 60),
woosh.Token(woosh.OP, ':', 1345, 60, 1345, 61),
woosh.Token(woosh.NEWLINE, '\r\n', 1345, 61, 1346, 0),
woosh.Token(woosh.INDENT, ' ', 1346, 0, 1346, 8),
woosh.Token(woosh.STRING, '"""Replace fields with supplemental information from a previous\r\n pax extended or global header.\r\n """', 1346, 8, 1348, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 1348, 11, 1349, 0),
woosh.Token(woosh.NAME, 'for', 1349, 8, 1349, 11),
woosh.Token(woosh.NAME, 'keyword', 1349, 12, 1349, 19),
woosh.Token(woosh.OP, ',', 1349, 19, 1349, 20),
woosh.Token(woosh.NAME, 'value', 1349, 21, 1349, 26),
woosh.Token(woosh.NAME, 'in', 1349, 27, 1349, 29),
woosh.Token(woosh.NAME, 'pax_headers', 1349, 30, 1349, 41),
woosh.Token(woosh.OP, '.', 1349, 41, 1349, 42),
woosh.Token(woosh.NAME, 'items', 1349, 42, 1349, 47),
woosh.Token(woosh.OP, '(', 1349, 47, 1349, 48),
woosh.Token(woosh.OP, ')', 1349, 48, 1349, 49),
woosh.Token(woosh.OP, ':', 1349, 49, 1349, 50),
woosh.Token(woosh.NEWLINE, '\r\n', 1349, 50, 1350, 0),
woosh.Token(woosh.INDENT, ' ', 1350, 0, 1350, 12),
woosh.Token(woosh.NAME, 'if', 1350, 12, 1350, 14),
woosh.Token(woosh.NAME, 'keyword', 1350, 15, 1350, 22),
woosh.Token(woosh.OP, '==', 1350, 23, 1350, 25),
woosh.Token(woosh.STRING, '"GNU.sparse.name"', 1350, 26, 1350, 43),
woosh.Token(woosh.OP, ':', 1350, 43, 1350, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 1350, 44, 1351, 0),
woosh.Token(woosh.INDENT, ' ', 1351, 0, 1351, 16),
woosh.Token(woosh.NAME, 'setattr', 1351, 16, 1351, 23),
woosh.Token(woosh.OP, '(', 1351, 23, 1351, 24),
woosh.Token(woosh.NAME, 'self', 1351, 24, 1351, 28),
woosh.Token(woosh.OP, ',', 1351, 28, 1351, 29),
woosh.Token(woosh.STRING, '"path"', 1351, 30, 1351, 36),
woosh.Token(woosh.OP, ',', 1351, 36, 1351, 37),
woosh.Token(woosh.NAME, 'value', 1351, 38, 1351, 43),
woosh.Token(woosh.OP, ')', 1351, 43, 1351, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 1351, 44, 1352, 0),
woosh.Token(woosh.DEDENT, ' ', 1352, 0, 1352, 12),
woosh.Token(woosh.NAME, 'elif', 1352, 12, 1352, 16),
woosh.Token(woosh.NAME, 'keyword', 1352, 17, 1352, 24),
woosh.Token(woosh.OP, '==', 1352, 25, 1352, 27),
woosh.Token(woosh.STRING, '"GNU.sparse.size"', 1352, 28, 1352, 45),
woosh.Token(woosh.OP, ':', 1352, 45, 1352, 46),
woosh.Token(woosh.NEWLINE, '\r\n', 1352, 46, 1353, 0),
woosh.Token(woosh.INDENT, ' ', 1353, 0, 1353, 16),
woosh.Token(woosh.NAME, 'setattr', 1353, 16, 1353, 23),
woosh.Token(woosh.OP, '(', 1353, 23, 1353, 24),
woosh.Token(woosh.NAME, 'self', 1353, 24, 1353, 28),
woosh.Token(woosh.OP, ',', 1353, 28, 1353, 29),
woosh.Token(woosh.STRING, '"size"', 1353, 30, 1353, 36),
woosh.Token(woosh.OP, ',', 1353, 36, 1353, 37),
woosh.Token(woosh.NAME, 'int', 1353, 38, 1353, 41),
woosh.Token(woosh.OP, '(', 1353, 41, 1353, 42),
woosh.Token(woosh.NAME, 'value', 1353, 42, 1353, 47),
woosh.Token(woosh.OP, ')', 1353, 47, 1353, 48),
woosh.Token(woosh.OP, ')', 1353, 48, 1353, 49),
woosh.Token(woosh.NEWLINE, '\r\n', 1353, 49, 1354, 0),
woosh.Token(woosh.DEDENT, ' ', 1354, 0, 1354, 12),
woosh.Token(woosh.NAME, 'elif', 1354, 12, 1354, 16),
woosh.Token(woosh.NAME, 'keyword', 1354, 17, 1354, 24),
woosh.Token(woosh.OP, '==', 1354, 25, 1354, 27),
woosh.Token(woosh.STRING, '"GNU.sparse.realsize"', 1354, 28, 1354, 49),
woosh.Token(woosh.OP, ':', 1354, 49, 1354, 50),
woosh.Token(woosh.NEWLINE, '\r\n', 1354, 50, 1355, 0),
woosh.Token(woosh.INDENT, ' ', 1355, 0, 1355, 16),
woosh.Token(woosh.NAME, 'setattr', 1355, 16, 1355, 23),
woosh.Token(woosh.OP, '(', 1355, 23, 1355, 24),
woosh.Token(woosh.NAME, 'self', 1355, 24, 1355, 28),
woosh.Token(woosh.OP, ',', 1355, 28, 1355, 29),
woosh.Token(woosh.STRING, '"size"', 1355, 30, 1355, 36),
woosh.Token(woosh.OP, ',', 1355, 36, 1355, 37),
woosh.Token(woosh.NAME, 'int', 1355, 38, 1355, 41),
woosh.Token(woosh.OP, '(', 1355, 41, 1355, 42),
woosh.Token(woosh.NAME, 'value', 1355, 42, 1355, 47),
woosh.Token(woosh.OP, ')', 1355, 47, 1355, 48),
woosh.Token(woosh.OP, ')', 1355, 48, 1355, 49),
woosh.Token(woosh.NEWLINE, '\r\n', 1355, 49, 1356, 0),
woosh.Token(woosh.DEDENT, ' ', 1356, 0, 1356, 12),
woosh.Token(woosh.NAME, 'elif', 1356, 12, 1356, 16),
woosh.Token(woosh.NAME, 'keyword', 1356, 17, 1356, 24),
woosh.Token(woosh.NAME, 'in', 1356, 25, 1356, 27),
woosh.Token(woosh.NAME, 'PAX_FIELDS', 1356, 28, 1356, 38),
woosh.Token(woosh.OP, ':', 1356, 38, 1356, 39),
woosh.Token(woosh.NEWLINE, '\r\n', 1356, 39, 1357, 0),
woosh.Token(woosh.INDENT, ' ', 1357, 0, 1357, 16),
woosh.Token(woosh.NAME, 'if', 1357, 16, 1357, 18),
woosh.Token(woosh.NAME, 'keyword', 1357, 19, 1357, 26),
woosh.Token(woosh.NAME, 'in', 1357, 27, 1357, 29),
woosh.Token(woosh.NAME, 'PAX_NUMBER_FIELDS', 1357, 30, 1357, 47),
woosh.Token(woosh.OP, ':', 1357, 47, 1357, 48),
woosh.Token(woosh.NEWLINE, '\r\n', 1357, 48, 1358, 0),
woosh.Token(woosh.INDENT, ' ', 1358, 0, 1358, 20),
woosh.Token(woosh.NAME, 'try', 1358, 20, 1358, 23),
woosh.Token(woosh.OP, ':', 1358, 23, 1358, 24),
woosh.Token(woosh.NEWLINE, '\r\n', 1358, 24, 1359, 0),
woosh.Token(woosh.INDENT, ' ', 1359, 0, 1359, 24),
woosh.Token(woosh.NAME, 'value', 1359, 24, 1359, 29),
woosh.Token(woosh.OP, '=', 1359, 30, 1359, 31),
woosh.Token(woosh.NAME, 'PAX_NUMBER_FIELDS', 1359, 32, 1359, 49),
woosh.Token(woosh.OP, '[', 1359, 49, 1359, 50),
woosh.Token(woosh.NAME, 'keyword', 1359, 50, 1359, 57),
woosh.Token(woosh.OP, ']', 1359, 57, 1359, 58),
woosh.Token(woosh.OP, '(', 1359, 58, 1359, 59),
woosh.Token(woosh.NAME, 'value', 1359, 59, 1359, 64),
woosh.Token(woosh.OP, ')', 1359, 64, 1359, 65),
woosh.Token(woosh.NEWLINE, '\r\n', 1359, 65, 1360, 0),
woosh.Token(woosh.DEDENT, ' ', 1360, 0, 1360, 20),
woosh.Token(woosh.NAME, 'except', 1360, 20, 1360, 26),
woosh.Token(woosh.NAME, 'ValueError', 1360, 27, 1360, 37),
woosh.Token(woosh.OP, ':', 1360, 37, 1360, 38),
woosh.Token(woosh.NEWLINE, '\r\n', 1360, 38, 1361, 0),
woosh.Token(woosh.INDENT, ' ', 1361, 0, 1361, 24),
woosh.Token(woosh.NAME, 'value', 1361, 24, 1361, 29),
woosh.Token(woosh.OP, '=', 1361, 30, 1361, 31),
woosh.Token(woosh.NUMBER, '0', 1361, 32, 1361, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 1361, 33, 1362, 0),
woosh.Token(woosh.DEDENT, ' ', 1362, 0, 1362, 16),
woosh.Token(woosh.DEDENT, '', 1362, 16, 1362, 16),
woosh.Token(woosh.NAME, 'if', 1362, 16, 1362, 18),
woosh.Token(woosh.NAME, 'keyword', 1362, 19, 1362, 26),
woosh.Token(woosh.OP, '==', 1362, 27, 1362, 29),
woosh.Token(woosh.STRING, '"path"', 1362, 30, 1362, 36),
woosh.Token(woosh.OP, ':', 1362, 36, 1362, 37),
woosh.Token(woosh.NEWLINE, '\r\n', 1362, 37, 1363, 0),
woosh.Token(woosh.INDENT, ' ', 1363, 0, 1363, 20),
woosh.Token(woosh.NAME, 'value', 1363, 20, 1363, 25),
woosh.Token(woosh.OP, '=', 1363, 26, 1363, 27),
woosh.Token(woosh.NAME, 'value', 1363, 28, 1363, 33),
woosh.Token(woosh.OP, '.', 1363, 33, 1363, 34),
woosh.Token(woosh.NAME, 'rstrip', 1363, 34, 1363, 40),
woosh.Token(woosh.OP, '(', 1363, 40, 1363, 41),
woosh.Token(woosh.STRING, '"/"', 1363, 41, 1363, 44),
woosh.Token(woosh.OP, ')', 1363, 44, 1363, 45),
woosh.Token(woosh.NEWLINE, '\r\n', 1363, 45, 1364, 0),
woosh.Token(woosh.DEDENT, ' ', 1364, 0, 1364, 16),
woosh.Token(woosh.NAME, 'setattr', 1364, 16, 1364, 23),
woosh.Token(woosh.OP, '(', 1364, 23, 1364, 24),
woosh.Token(woosh.NAME, 'self', 1364, 24, 1364, 28),
woosh.Token(woosh.OP, ',', 1364, 28, 1364, 29),
woosh.Token(woosh.NAME, 'keyword', 1364, 30, 1364, 37),
woosh.Token(woosh.OP, ',', 1364, 37, 1364, 38),
woosh.Token(woosh.NAME, 'value', 1364, 39, 1364, 44),
woosh.Token(woosh.OP, ')', 1364, 44, 1364, 45),
woosh.Token(woosh.NEWLINE, '\r\n', 1364, 45, 1365, 0),
woosh.Token(woosh.DEDENT, ' ', 1366, 0, 1366, 8),
woosh.Token(woosh.DEDENT, '', 1366, 8, 1366, 8),
woosh.Token(woosh.NAME, 'self', 1366, 8, 1366, 12),
woosh.Token(woosh.OP, '.', 1366, 12, 1366, 13),
woosh.Token(woosh.NAME, 'pax_headers', 1366, 13, 1366, 24),
woosh.Token(woosh.OP, '=', 1366, 25, 1366, 26),
woosh.Token(woosh.NAME, 'pax_headers', 1366, 27, 1366, 38),
woosh.Token(woosh.OP, '.', 1366, 38, 1366, 39),
woosh.Token(woosh.NAME, 'copy', 1366, 39, 1366, 43),
woosh.Token(woosh.OP, '(', 1366, 43, 1366, 44),
woosh.Token(woosh.OP, ')', 1366, 44, 1366, 45),
woosh.Token(woosh.NEWLINE, '\r\n', 1366, 45, 1367, 0),
woosh.Token(woosh.DEDENT, ' ', 1368, 0, 1368, 4),
woosh.Token(woosh.NAME, 'def', 1368, 4, 1368, 7),
woosh.Token(woosh.NAME, '_decode_pax_field', 1368, 8, 1368, 25),
woosh.Token(woosh.OP, '(', 1368, 25, 1368, 26),
woosh.Token(woosh.NAME, 'self', 1368, 26, 1368, 30),
woosh.Token(woosh.OP, ',', 1368, 30, 1368, 31),
woosh.Token(woosh.NAME, 'value', 1368, 32, 1368, 37),
woosh.Token(woosh.OP, ',', 1368, 37, 1368, 38),
woosh.Token(woosh.NAME, 'encoding', 1368, 39, 1368, 47),
woosh.Token(woosh.OP, ',', 1368, 47, 1368, 48),
woosh.Token(woosh.NAME, 'fallback_encoding', 1368, 49, 1368, 66),
woosh.Token(woosh.OP, ',', 1368, 66, 1368, 67),
woosh.Token(woosh.NAME, 'fallback_errors', 1368, 68, 1368, 83),
woosh.Token(woosh.OP, ')', 1368, 83, 1368, 84),
woosh.Token(woosh.OP, ':', 1368, 84, 1368, 85),
woosh.Token(woosh.NEWLINE, '\r\n', 1368, 85, 1369, 0),
woosh.Token(woosh.INDENT, ' ', 1369, 0, 1369, 8),
woosh.Token(woosh.STRING, '"""Decode a single field from a pax record.\r\n """', 1369, 8, 1370, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 1370, 11, 1371, 0),
woosh.Token(woosh.NAME, 'try', 1371, 8, 1371, 11),
woosh.Token(woosh.OP, ':', 1371, 11, 1371, 12),
woosh.Token(woosh.NEWLINE, '\r\n', 1371, 12, 1372, 0),
woosh.Token(woosh.INDENT, ' ', 1372, 0, 1372, 12),
woosh.Token(woosh.NAME, 'return', 1372, 12, 1372, 18),
woosh.Token(woosh.NAME, 'value', 1372, 19, 1372, 24),
woosh.Token(woosh.OP, '.', 1372, 24, 1372, 25),
woosh.Token(woosh.NAME, 'decode', 1372, 25, 1372, 31),
woosh.Token(woosh.OP, '(', 1372, 31, 1372, 32),
woosh.Token(woosh.NAME, 'encoding', 1372, 32, 1372, 40),
woosh.Token(woosh.OP, ',', 1372, 40, 1372, 41),
woosh.Token(woosh.STRING, '"strict"', 1372, 42, 1372, 50),
woosh.Token(woosh.OP, ')', 1372, 50, 1372, 51),
woosh.Token(woosh.NEWLINE, '\r\n', 1372, 51, 1373, 0),
woosh.Token(woosh.DEDENT, ' ', 1373, 0, 1373, 8),
woosh.Token(woosh.NAME, 'except', 1373, 8, 1373, 14),
woosh.Token(woosh.NAME, 'UnicodeDecodeError', 1373, 15, 1373, 33),
woosh.Token(woosh.OP, ':', 1373, 33, 1373, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 1373, 34, 1374, 0),
woosh.Token(woosh.INDENT, ' ', 1374, 0, 1374, 12),
woosh.Token(woosh.NAME, 'return', 1374, 12, 1374, 18),
woosh.Token(woosh.NAME, 'value', 1374, 19, 1374, 24),
woosh.Token(woosh.OP, '.', 1374, 24, 1374, 25),
woosh.Token(woosh.NAME, 'decode', 1374, 25, 1374, 31),
woosh.Token(woosh.OP, '(', 1374, 31, 1374, 32),
woosh.Token(woosh.NAME, 'fallback_encoding', 1374, 32, 1374, 49),
woosh.Token(woosh.OP, ',', 1374, 49, 1374, 50),
woosh.Token(woosh.NAME, 'fallback_errors', 1374, 51, 1374, 66),
woosh.Token(woosh.OP, ')', 1374, 66, 1374, 67),
woosh.Token(woosh.NEWLINE, '\r\n', 1374, 67, 1375, 0),
woosh.Token(woosh.DEDENT, ' ', 1376, 0, 1376, 4),
woosh.Token(woosh.DEDENT, '', 1376, 4, 1376, 4),
woosh.Token(woosh.NAME, 'def', 1376, 4, 1376, 7),
woosh.Token(woosh.NAME, '_block', 1376, 8, 1376, 14),
woosh.Token(woosh.OP, '(', 1376, 14, 1376, 15),
woosh.Token(woosh.NAME, 'self', 1376, 15, 1376, 19),
woosh.Token(woosh.OP, ',', 1376, 19, 1376, 20),
woosh.Token(woosh.NAME, 'count', 1376, 21, 1376, 26),
woosh.Token(woosh.OP, ')', 1376, 26, 1376, 27),
woosh.Token(woosh.OP, ':', 1376, 27, 1376, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 1376, 28, 1377, 0),
woosh.Token(woosh.INDENT, ' ', 1377, 0, 1377, 8),
woosh.Token(woosh.STRING, '"""Round up a byte count by BLOCKSIZE and return it,\r\n e.g. _block(834) => 1024.\r\n """', 1377, 8, 1379, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 1379, 11, 1380, 0),
woosh.Token(woosh.NAME, 'blocks', 1380, 8, 1380, 14),
woosh.Token(woosh.OP, ',', 1380, 14, 1380, 15),
woosh.Token(woosh.NAME, 'remainder', 1380, 16, 1380, 25),
woosh.Token(woosh.OP, '=', 1380, 26, 1380, 27),
woosh.Token(woosh.NAME, 'divmod', 1380, 28, 1380, 34),
woosh.Token(woosh.OP, '(', 1380, 34, 1380, 35),
woosh.Token(woosh.NAME, 'count', 1380, 35, 1380, 40),
woosh.Token(woosh.OP, ',', 1380, 40, 1380, 41),
woosh.Token(woosh.NAME, 'BLOCKSIZE', 1380, 42, 1380, 51),
woosh.Token(woosh.OP, ')', 1380, 51, 1380, 52),
woosh.Token(woosh.NEWLINE, '\r\n', 1380, 52, 1381, 0),
woosh.Token(woosh.NAME, 'if', 1381, 8, 1381, 10),
woosh.Token(woosh.NAME, 'remainder', 1381, 11, 1381, 20),
woosh.Token(woosh.OP, ':', 1381, 20, 1381, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 1381, 21, 1382, 0),
woosh.Token(woosh.INDENT, ' ', 1382, 0, 1382, 12),
woosh.Token(woosh.NAME, 'blocks', 1382, 12, 1382, 18),
woosh.Token(woosh.OP, '+=', 1382, 19, 1382, 21),
woosh.Token(woosh.NUMBER, '1', 1382, 22, 1382, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 1382, 23, 1383, 0),
woosh.Token(woosh.DEDENT, ' ', 1383, 0, 1383, 8),
woosh.Token(woosh.NAME, 'return', 1383, 8, 1383, 14),
woosh.Token(woosh.NAME, 'blocks', 1383, 15, 1383, 21),
woosh.Token(woosh.OP, '*', 1383, 22, 1383, 23),
woosh.Token(woosh.NAME, 'BLOCKSIZE', 1383, 24, 1383, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 1383, 33, 1384, 0),
woosh.Token(woosh.DEDENT, ' ', 1385, 0, 1385, 4),
woosh.Token(woosh.NAME, 'def', 1385, 4, 1385, 7),
woosh.Token(woosh.NAME, 'isreg', 1385, 8, 1385, 13),
woosh.Token(woosh.OP, '(', 1385, 13, 1385, 14),
woosh.Token(woosh.NAME, 'self', 1385, 14, 1385, 18),
woosh.Token(woosh.OP, ')', 1385, 18, 1385, 19),
woosh.Token(woosh.OP, ':', 1385, 19, 1385, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 1385, 20, 1386, 0),
woosh.Token(woosh.INDENT, ' ', 1386, 0, 1386, 8),
woosh.Token(woosh.STRING, "'Return True if the Tarinfo object is a regular file.'", 1386, 8, 1386, 62),
woosh.Token(woosh.NEWLINE, '\r\n', 1386, 62, 1387, 0),
woosh.Token(woosh.NAME, 'return', 1387, 8, 1387, 14),
woosh.Token(woosh.NAME, 'self', 1387, 15, 1387, 19),
woosh.Token(woosh.OP, '.', 1387, 19, 1387, 20),
woosh.Token(woosh.NAME, 'type', 1387, 20, 1387, 24),
woosh.Token(woosh.NAME, 'in', 1387, 25, 1387, 27),
woosh.Token(woosh.NAME, 'REGULAR_TYPES', 1387, 28, 1387, 41),
woosh.Token(woosh.NEWLINE, '\r\n', 1387, 41, 1388, 0),
woosh.Token(woosh.DEDENT, ' ', 1389, 0, 1389, 4),
woosh.Token(woosh.NAME, 'def', 1389, 4, 1389, 7),
woosh.Token(woosh.NAME, 'isfile', 1389, 8, 1389, 14),
woosh.Token(woosh.OP, '(', 1389, 14, 1389, 15),
woosh.Token(woosh.NAME, 'self', 1389, 15, 1389, 19),
woosh.Token(woosh.OP, ')', 1389, 19, 1389, 20),
woosh.Token(woosh.OP, ':', 1389, 20, 1389, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 1389, 21, 1390, 0),
woosh.Token(woosh.INDENT, ' ', 1390, 0, 1390, 8),
woosh.Token(woosh.STRING, "'Return True if the Tarinfo object is a regular file.'", 1390, 8, 1390, 62),
woosh.Token(woosh.NEWLINE, '\r\n', 1390, 62, 1391, 0),
woosh.Token(woosh.NAME, 'return', 1391, 8, 1391, 14),
woosh.Token(woosh.NAME, 'self', 1391, 15, 1391, 19),
woosh.Token(woosh.OP, '.', 1391, 19, 1391, 20),
woosh.Token(woosh.NAME, 'isreg', 1391, 20, 1391, 25),
woosh.Token(woosh.OP, '(', 1391, 25, 1391, 26),
woosh.Token(woosh.OP, ')', 1391, 26, 1391, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 1391, 27, 1392, 0),
woosh.Token(woosh.DEDENT, ' ', 1393, 0, 1393, 4),
woosh.Token(woosh.NAME, 'def', 1393, 4, 1393, 7),
woosh.Token(woosh.NAME, 'isdir', 1393, 8, 1393, 13),
woosh.Token(woosh.OP, '(', 1393, 13, 1393, 14),
woosh.Token(woosh.NAME, 'self', 1393, 14, 1393, 18),
woosh.Token(woosh.OP, ')', 1393, 18, 1393, 19),
woosh.Token(woosh.OP, ':', 1393, 19, 1393, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 1393, 20, 1394, 0),
woosh.Token(woosh.INDENT, ' ', 1394, 0, 1394, 8),
woosh.Token(woosh.STRING, "'Return True if it is a directory.'", 1394, 8, 1394, 43),
woosh.Token(woosh.NEWLINE, '\r\n', 1394, 43, 1395, 0),
woosh.Token(woosh.NAME, 'return', 1395, 8, 1395, 14),
woosh.Token(woosh.NAME, 'self', 1395, 15, 1395, 19),
woosh.Token(woosh.OP, '.', 1395, 19, 1395, 20),
woosh.Token(woosh.NAME, 'type', 1395, 20, 1395, 24),
woosh.Token(woosh.OP, '==', 1395, 25, 1395, 27),
woosh.Token(woosh.NAME, 'DIRTYPE', 1395, 28, 1395, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 1395, 35, 1396, 0),
woosh.Token(woosh.DEDENT, ' ', 1397, 0, 1397, 4),
woosh.Token(woosh.NAME, 'def', 1397, 4, 1397, 7),
woosh.Token(woosh.NAME, 'issym', 1397, 8, 1397, 13),
woosh.Token(woosh.OP, '(', 1397, 13, 1397, 14),
woosh.Token(woosh.NAME, 'self', 1397, 14, 1397, 18),
woosh.Token(woosh.OP, ')', 1397, 18, 1397, 19),
woosh.Token(woosh.OP, ':', 1397, 19, 1397, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 1397, 20, 1398, 0),
woosh.Token(woosh.INDENT, ' ', 1398, 0, 1398, 8),
woosh.Token(woosh.STRING, "'Return True if it is a symbolic link.'", 1398, 8, 1398, 47),
woosh.Token(woosh.NEWLINE, '\r\n', 1398, 47, 1399, 0),
woosh.Token(woosh.NAME, 'return', 1399, 8, 1399, 14),
woosh.Token(woosh.NAME, 'self', 1399, 15, 1399, 19),
woosh.Token(woosh.OP, '.', 1399, 19, 1399, 20),
woosh.Token(woosh.NAME, 'type', 1399, 20, 1399, 24),
woosh.Token(woosh.OP, '==', 1399, 25, 1399, 27),
woosh.Token(woosh.NAME, 'SYMTYPE', 1399, 28, 1399, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 1399, 35, 1400, 0),
woosh.Token(woosh.DEDENT, ' ', 1401, 0, 1401, 4),
woosh.Token(woosh.NAME, 'def', 1401, 4, 1401, 7),
woosh.Token(woosh.NAME, 'islnk', 1401, 8, 1401, 13),
woosh.Token(woosh.OP, '(', 1401, 13, 1401, 14),
woosh.Token(woosh.NAME, 'self', 1401, 14, 1401, 18),
woosh.Token(woosh.OP, ')', 1401, 18, 1401, 19),
woosh.Token(woosh.OP, ':', 1401, 19, 1401, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 1401, 20, 1402, 0),
woosh.Token(woosh.INDENT, ' ', 1402, 0, 1402, 8),
woosh.Token(woosh.STRING, "'Return True if it is a hard link.'", 1402, 8, 1402, 43),
woosh.Token(woosh.NEWLINE, '\r\n', 1402, 43, 1403, 0),
woosh.Token(woosh.NAME, 'return', 1403, 8, 1403, 14),
woosh.Token(woosh.NAME, 'self', 1403, 15, 1403, 19),
woosh.Token(woosh.OP, '.', 1403, 19, 1403, 20),
woosh.Token(woosh.NAME, 'type', 1403, 20, 1403, 24),
woosh.Token(woosh.OP, '==', 1403, 25, 1403, 27),
woosh.Token(woosh.NAME, 'LNKTYPE', 1403, 28, 1403, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 1403, 35, 1404, 0),
woosh.Token(woosh.DEDENT, ' ', 1405, 0, 1405, 4),
woosh.Token(woosh.NAME, 'def', 1405, 4, 1405, 7),
woosh.Token(woosh.NAME, 'ischr', 1405, 8, 1405, 13),
woosh.Token(woosh.OP, '(', 1405, 13, 1405, 14),
woosh.Token(woosh.NAME, 'self', 1405, 14, 1405, 18),
woosh.Token(woosh.OP, ')', 1405, 18, 1405, 19),
woosh.Token(woosh.OP, ':', 1405, 19, 1405, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 1405, 20, 1406, 0),
woosh.Token(woosh.INDENT, ' ', 1406, 0, 1406, 8),
woosh.Token(woosh.STRING, "'Return True if it is a character device.'", 1406, 8, 1406, 50),
woosh.Token(woosh.NEWLINE, '\r\n', 1406, 50, 1407, 0),
woosh.Token(woosh.NAME, 'return', 1407, 8, 1407, 14),
woosh.Token(woosh.NAME, 'self', 1407, 15, 1407, 19),
woosh.Token(woosh.OP, '.', 1407, 19, 1407, 20),
woosh.Token(woosh.NAME, 'type', 1407, 20, 1407, 24),
woosh.Token(woosh.OP, '==', 1407, 25, 1407, 27),
woosh.Token(woosh.NAME, 'CHRTYPE', 1407, 28, 1407, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 1407, 35, 1408, 0),
woosh.Token(woosh.DEDENT, ' ', 1409, 0, 1409, 4),
woosh.Token(woosh.NAME, 'def', 1409, 4, 1409, 7),
woosh.Token(woosh.NAME, 'isblk', 1409, 8, 1409, 13),
woosh.Token(woosh.OP, '(', 1409, 13, 1409, 14),
woosh.Token(woosh.NAME, 'self', 1409, 14, 1409, 18),
woosh.Token(woosh.OP, ')', 1409, 18, 1409, 19),
woosh.Token(woosh.OP, ':', 1409, 19, 1409, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 1409, 20, 1410, 0),
woosh.Token(woosh.INDENT, ' ', 1410, 0, 1410, 8),
woosh.Token(woosh.STRING, "'Return True if it is a block device.'", 1410, 8, 1410, 46),
woosh.Token(woosh.NEWLINE, '\r\n', 1410, 46, 1411, 0),
woosh.Token(woosh.NAME, 'return', 1411, 8, 1411, 14),
woosh.Token(woosh.NAME, 'self', 1411, 15, 1411, 19),
woosh.Token(woosh.OP, '.', 1411, 19, 1411, 20),
woosh.Token(woosh.NAME, 'type', 1411, 20, 1411, 24),
woosh.Token(woosh.OP, '==', 1411, 25, 1411, 27),
woosh.Token(woosh.NAME, 'BLKTYPE', 1411, 28, 1411, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 1411, 35, 1412, 0),
woosh.Token(woosh.DEDENT, ' ', 1413, 0, 1413, 4),
woosh.Token(woosh.NAME, 'def', 1413, 4, 1413, 7),
woosh.Token(woosh.NAME, 'isfifo', 1413, 8, 1413, 14),
woosh.Token(woosh.OP, '(', 1413, 14, 1413, 15),
woosh.Token(woosh.NAME, 'self', 1413, 15, 1413, 19),
woosh.Token(woosh.OP, ')', 1413, 19, 1413, 20),
woosh.Token(woosh.OP, ':', 1413, 20, 1413, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 1413, 21, 1414, 0),
woosh.Token(woosh.INDENT, ' ', 1414, 0, 1414, 8),
woosh.Token(woosh.STRING, "'Return True if it is a FIFO.'", 1414, 8, 1414, 38),
woosh.Token(woosh.NEWLINE, '\r\n', 1414, 38, 1415, 0),
woosh.Token(woosh.NAME, 'return', 1415, 8, 1415, 14),
woosh.Token(woosh.NAME, 'self', 1415, 15, 1415, 19),
woosh.Token(woosh.OP, '.', 1415, 19, 1415, 20),
woosh.Token(woosh.NAME, 'type', 1415, 20, 1415, 24),
woosh.Token(woosh.OP, '==', 1415, 25, 1415, 27),
woosh.Token(woosh.NAME, 'FIFOTYPE', 1415, 28, 1415, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 1415, 36, 1416, 0),
woosh.Token(woosh.DEDENT, ' ', 1417, 0, 1417, 4),
woosh.Token(woosh.NAME, 'def', 1417, 4, 1417, 7),
woosh.Token(woosh.NAME, 'issparse', 1417, 8, 1417, 16),
woosh.Token(woosh.OP, '(', 1417, 16, 1417, 17),
woosh.Token(woosh.NAME, 'self', 1417, 17, 1417, 21),
woosh.Token(woosh.OP, ')', 1417, 21, 1417, 22),
woosh.Token(woosh.OP, ':', 1417, 22, 1417, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 1417, 23, 1418, 0),
woosh.Token(woosh.INDENT, ' ', 1418, 0, 1418, 8),
woosh.Token(woosh.NAME, 'return', 1418, 8, 1418, 14),
woosh.Token(woosh.NAME, 'self', 1418, 15, 1418, 19),
woosh.Token(woosh.OP, '.', 1418, 19, 1418, 20),
woosh.Token(woosh.NAME, 'sparse', 1418, 20, 1418, 26),
woosh.Token(woosh.NAME, 'is', 1418, 27, 1418, 29),
woosh.Token(woosh.NAME, 'not', 1418, 30, 1418, 33),
woosh.Token(woosh.NAME, 'None', 1418, 34, 1418, 38),
woosh.Token(woosh.NEWLINE, '\r\n', 1418, 38, 1419, 0),
woosh.Token(woosh.DEDENT, ' ', 1420, 0, 1420, 4),
woosh.Token(woosh.NAME, 'def', 1420, 4, 1420, 7),
woosh.Token(woosh.NAME, 'isdev', 1420, 8, 1420, 13),
woosh.Token(woosh.OP, '(', 1420, 13, 1420, 14),
woosh.Token(woosh.NAME, 'self', 1420, 14, 1420, 18),
woosh.Token(woosh.OP, ')', 1420, 18, 1420, 19),
woosh.Token(woosh.OP, ':', 1420, 19, 1420, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 1420, 20, 1421, 0),
woosh.Token(woosh.INDENT, ' ', 1421, 0, 1421, 8),
woosh.Token(woosh.STRING, "'Return True if it is one of character device, block device or FIFO.'", 1421, 8, 1421, 77),
woosh.Token(woosh.NEWLINE, '\r\n', 1421, 77, 1422, 0),
woosh.Token(woosh.NAME, 'return', 1422, 8, 1422, 14),
woosh.Token(woosh.NAME, 'self', 1422, 15, 1422, 19),
woosh.Token(woosh.OP, '.', 1422, 19, 1422, 20),
woosh.Token(woosh.NAME, 'type', 1422, 20, 1422, 24),
woosh.Token(woosh.NAME, 'in', 1422, 25, 1422, 27),
woosh.Token(woosh.OP, '(', 1422, 28, 1422, 29),
woosh.Token(woosh.NAME, 'CHRTYPE', 1422, 29, 1422, 36),
woosh.Token(woosh.OP, ',', 1422, 36, 1422, 37),
woosh.Token(woosh.NAME, 'BLKTYPE', 1422, 38, 1422, 45),
woosh.Token(woosh.OP, ',', 1422, 45, 1422, 46),
woosh.Token(woosh.NAME, 'FIFOTYPE', 1422, 47, 1422, 55),
woosh.Token(woosh.OP, ')', 1422, 55, 1422, 56),
woosh.Token(woosh.NEWLINE, '\r\n', 1422, 56, 1423, 0),
woosh.Token(woosh.COMMENT, '# class TarInfo', 1423, 0, 1423, 15),
woosh.Token(woosh.DEDENT, '', 1425, 0, 1425, 0),
woosh.Token(woosh.DEDENT, '', 1425, 0, 1425, 0),
woosh.Token(woosh.NAME, 'class', 1425, 0, 1425, 5),
woosh.Token(woosh.NAME, 'TarFile', 1425, 6, 1425, 13),
woosh.Token(woosh.OP, '(', 1425, 13, 1425, 14),
woosh.Token(woosh.NAME, 'object', 1425, 14, 1425, 20),
woosh.Token(woosh.OP, ')', 1425, 20, 1425, 21),
woosh.Token(woosh.OP, ':', 1425, 21, 1425, 22),
woosh.Token(woosh.NEWLINE, '\r\n', 1425, 22, 1426, 0),
woosh.Token(woosh.INDENT, ' ', 1426, 0, 1426, 4),
woosh.Token(woosh.STRING, '"""The TarFile Class provides an interface to tar archives.\r\n """', 1426, 4, 1427, 7),
woosh.Token(woosh.NEWLINE, '\r\n', 1427, 7, 1428, 0),
woosh.Token(woosh.NAME, 'debug', 1429, 4, 1429, 9),
woosh.Token(woosh.OP, '=', 1429, 10, 1429, 11),
woosh.Token(woosh.NUMBER, '0', 1429, 12, 1429, 13),
woosh.Token(woosh.COMMENT, '# May be set from 0 (no msgs) to 3 (all msgs)', 1429, 32, 1429, 77),
woosh.Token(woosh.NEWLINE, '\r\n', 1429, 77, 1430, 0),
woosh.Token(woosh.NAME, 'dereference', 1431, 4, 1431, 15),
woosh.Token(woosh.OP, '=', 1431, 16, 1431, 17),
woosh.Token(woosh.NAME, 'False', 1431, 18, 1431, 23),
woosh.Token(woosh.COMMENT, '# If true, add content of linked file to the', 1431, 32, 1431, 76),
woosh.Token(woosh.NEWLINE, '\r\n', 1431, 76, 1432, 0),
woosh.Token(woosh.COMMENT, '# tar file, else the link.', 1432, 32, 1432, 58),
woosh.Token(woosh.NAME, 'ignore_zeros', 1434, 4, 1434, 16),
woosh.Token(woosh.OP, '=', 1434, 17, 1434, 18),
woosh.Token(woosh.NAME, 'False', 1434, 19, 1434, 24),
woosh.Token(woosh.COMMENT, '# If true, skips empty or invalid blocks and', 1434, 32, 1434, 76),
woosh.Token(woosh.NEWLINE, '\r\n', 1434, 76, 1435, 0),
woosh.Token(woosh.COMMENT, '# continues processing.', 1435, 32, 1435, 55),
woosh.Token(woosh.NAME, 'errorlevel', 1437, 4, 1437, 14),
woosh.Token(woosh.OP, '=', 1437, 15, 1437, 16),
woosh.Token(woosh.NUMBER, '1', 1437, 17, 1437, 18),
woosh.Token(woosh.COMMENT, '# If 0, fatal errors only appear in debug', 1437, 32, 1437, 73),
woosh.Token(woosh.NEWLINE, '\r\n', 1437, 73, 1438, 0),
woosh.Token(woosh.COMMENT, '# messages (if debug >= 0). If > 0, errors', 1438, 32, 1438, 74),
woosh.Token(woosh.COMMENT, '# are passed to the caller as exceptions.', 1439, 32, 1439, 73),
woosh.Token(woosh.NAME, 'format', 1441, 4, 1441, 10),
woosh.Token(woosh.OP, '=', 1441, 11, 1441, 12),
woosh.Token(woosh.NAME, 'DEFAULT_FORMAT', 1441, 13, 1441, 27),
woosh.Token(woosh.COMMENT, '# The format to use when creating an archive.', 1441, 32, 1441, 77),
woosh.Token(woosh.NEWLINE, '\r\n', 1441, 77, 1442, 0),
woosh.Token(woosh.NAME, 'encoding', 1443, 4, 1443, 12),
woosh.Token(woosh.OP, '=', 1443, 13, 1443, 14),
woosh.Token(woosh.NAME, 'ENCODING', 1443, 15, 1443, 23),
woosh.Token(woosh.COMMENT, '# Encoding for 8-bit character strings.', 1443, 32, 1443, 71),
woosh.Token(woosh.NEWLINE, '\r\n', 1443, 71, 1444, 0),
woosh.Token(woosh.NAME, 'errors', 1445, 4, 1445, 10),
woosh.Token(woosh.OP, '=', 1445, 11, 1445, 12),
woosh.Token(woosh.NAME, 'None', 1445, 13, 1445, 17),
woosh.Token(woosh.COMMENT, '# Error handler for unicode conversion.', 1445, 32, 1445, 71),
woosh.Token(woosh.NEWLINE, '\r\n', 1445, 71, 1446, 0),
woosh.Token(woosh.NAME, 'tarinfo', 1447, 4, 1447, 11),
woosh.Token(woosh.OP, '=', 1447, 12, 1447, 13),
woosh.Token(woosh.NAME, 'TarInfo', 1447, 14, 1447, 21),
woosh.Token(woosh.COMMENT, '# The default TarInfo class to use.', 1447, 32, 1447, 67),
woosh.Token(woosh.NEWLINE, '\r\n', 1447, 67, 1448, 0),
woosh.Token(woosh.NAME, 'fileobject', 1449, 4, 1449, 14),
woosh.Token(woosh.OP, '=', 1449, 15, 1449, 16),
woosh.Token(woosh.NAME, 'ExFileObject', 1449, 17, 1449, 29),
woosh.Token(woosh.COMMENT, '# The file-object for extractfile().', 1449, 32, 1449, 68),
woosh.Token(woosh.NEWLINE, '\r\n', 1449, 68, 1450, 0),
woosh.Token(woosh.NAME, 'def', 1451, 4, 1451, 7),
woosh.Token(woosh.NAME, '__init__', 1451, 8, 1451, 16),
woosh.Token(woosh.OP, '(', 1451, 16, 1451, 17),
woosh.Token(woosh.NAME, 'self', 1451, 17, 1451, 21),
woosh.Token(woosh.OP, ',', 1451, 21, 1451, 22),
woosh.Token(woosh.NAME, 'name', 1451, 23, 1451, 27),
woosh.Token(woosh.OP, '=', 1451, 27, 1451, 28),
woosh.Token(woosh.NAME, 'None', 1451, 28, 1451, 32),
woosh.Token(woosh.OP, ',', 1451, 32, 1451, 33),
woosh.Token(woosh.NAME, 'mode', 1451, 34, 1451, 38),
woosh.Token(woosh.OP, '=', 1451, 38, 1451, 39),
woosh.Token(woosh.STRING, '"r"', 1451, 39, 1451, 42),
woosh.Token(woosh.OP, ',', 1451, 42, 1451, 43),
woosh.Token(woosh.NAME, 'fileobj', 1451, 44, 1451, 51),
woosh.Token(woosh.OP, '=', 1451, 51, 1451, 52),
woosh.Token(woosh.NAME, 'None', 1451, 52, 1451, 56),
woosh.Token(woosh.OP, ',', 1451, 56, 1451, 57),
woosh.Token(woosh.NAME, 'format', 1451, 58, 1451, 64),
woosh.Token(woosh.OP, '=', 1451, 64, 1451, 65),
woosh.Token(woosh.NAME, 'None', 1451, 65, 1451, 69),
woosh.Token(woosh.OP, ',', 1451, 69, 1451, 70),
woosh.Token(woosh.NAME, 'tarinfo', 1452, 12, 1452, 19),
woosh.Token(woosh.OP, '=', 1452, 19, 1452, 20),
woosh.Token(woosh.NAME, 'None', 1452, 20, 1452, 24),
woosh.Token(woosh.OP, ',', 1452, 24, 1452, 25),
woosh.Token(woosh.NAME, 'dereference', 1452, 26, 1452, 37),
woosh.Token(woosh.OP, '=', 1452, 37, 1452, 38),
woosh.Token(woosh.NAME, 'None', 1452, 38, 1452, 42),
woosh.Token(woosh.OP, ',', 1452, 42, 1452, 43),
woosh.Token(woosh.NAME, 'ignore_zeros', 1452, 44, 1452, 56),
woosh.Token(woosh.OP, '=', 1452, 56, 1452, 57),
woosh.Token(woosh.NAME, 'None', 1452, 57, 1452, 61),
woosh.Token(woosh.OP, ',', 1452, 61, 1452, 62),
woosh.Token(woosh.NAME, 'encoding', 1452, 63, 1452, 71),
woosh.Token(woosh.OP, '=', 1452, 71, 1452, 72),
woosh.Token(woosh.NAME, 'None', 1452, 72, 1452, 76),
woosh.Token(woosh.OP, ',', 1452, 76, 1452, 77),
woosh.Token(woosh.NAME, 'errors', 1453, 12, 1453, 18),
woosh.Token(woosh.OP, '=', 1453, 18, 1453, 19),
woosh.Token(woosh.STRING, '"surrogateescape"', 1453, 19, 1453, 36),
woosh.Token(woosh.OP, ',', 1453, 36, 1453, 37),
woosh.Token(woosh.NAME, 'pax_headers', 1453, 38, 1453, 49),
woosh.Token(woosh.OP, '=', 1453, 49, 1453, 50),
woosh.Token(woosh.NAME, 'None', 1453, 50, 1453, 54),
woosh.Token(woosh.OP, ',', 1453, 54, 1453, 55),
woosh.Token(woosh.NAME, 'debug', 1453, 56, 1453, 61),
woosh.Token(woosh.OP, '=', 1453, 61, 1453, 62),
woosh.Token(woosh.NAME, 'None', 1453, 62, 1453, 66),
woosh.Token(woosh.OP, ',', 1453, 66, 1453, 67),
woosh.Token(woosh.NAME, 'errorlevel', 1454, 12, 1454, 22),
woosh.Token(woosh.OP, '=', 1454, 22, 1454, 23),
woosh.Token(woosh.NAME, 'None', 1454, 23, 1454, 27),
woosh.Token(woosh.OP, ',', 1454, 27, 1454, 28),
woosh.Token(woosh.NAME, 'copybufsize', 1454, 29, 1454, 40),
woosh.Token(woosh.OP, '=', 1454, 40, 1454, 41),
woosh.Token(woosh.NAME, 'None', 1454, 41, 1454, 45),
woosh.Token(woosh.OP, ')', 1454, 45, 1454, 46),
woosh.Token(woosh.OP, ':', 1454, 46, 1454, 47),
woosh.Token(woosh.NEWLINE, '\r\n', 1454, 47, 1455, 0),
woosh.Token(woosh.INDENT, ' ', 1455, 0, 1455, 8),
woosh.Token(woosh.STRING, '"""Open an (uncompressed) tar archive `name\'. `mode\' is either \'r\' to\r\n read from an existing archive, \'a\' to append data to an existing\r\n file or \'w\' to create a new file overwriting an existing one. `mode\'\r\n defaults to \'r\'.\r\n If `fileobj\' is given, it is used for reading or writing data. If it\r\n can be determined, `mode\' is overridden by `fileobj\'s mode.\r\n `fileobj\' is not closed, when TarFile is closed.\r\n """', 1455, 8, 1462, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 1462, 11, 1463, 0),
woosh.Token(woosh.NAME, 'modes', 1463, 8, 1463, 13),
woosh.Token(woosh.OP, '=', 1463, 14, 1463, 15),
woosh.Token(woosh.OP, '{', 1463, 16, 1463, 17),
woosh.Token(woosh.STRING, '"r"', 1463, 17, 1463, 20),
woosh.Token(woosh.OP, ':', 1463, 20, 1463, 21),
woosh.Token(woosh.STRING, '"rb"', 1463, 22, 1463, 26),
woosh.Token(woosh.OP, ',', 1463, 26, 1463, 27),
woosh.Token(woosh.STRING, '"a"', 1463, 28, 1463, 31),
woosh.Token(woosh.OP, ':', 1463, 31, 1463, 32),
woosh.Token(woosh.STRING, '"r+b"', 1463, 33, 1463, 38),
woosh.Token(woosh.OP, ',', 1463, 38, 1463, 39),
woosh.Token(woosh.STRING, '"w"', 1463, 40, 1463, 43),
woosh.Token(woosh.OP, ':', 1463, 43, 1463, 44),
woosh.Token(woosh.STRING, '"wb"', 1463, 45, 1463, 49),
woosh.Token(woosh.OP, ',', 1463, 49, 1463, 50),
woosh.Token(woosh.STRING, '"x"', 1463, 51, 1463, 54),
woosh.Token(woosh.OP, ':', 1463, 54, 1463, 55),
woosh.Token(woosh.STRING, '"xb"', 1463, 56, 1463, 60),
woosh.Token(woosh.OP, '}', 1463, 60, 1463, 61),
woosh.Token(woosh.NEWLINE, '\r\n', 1463, 61, 1464, 0),
woosh.Token(woosh.NAME, 'if', 1464, 8, 1464, 10),
woosh.Token(woosh.NAME, 'mode', 1464, 11, 1464, 15),
woosh.Token(woosh.NAME, 'not', 1464, 16, 1464, 19),
woosh.Token(woosh.NAME, 'in', 1464, 20, 1464, 22),
woosh.Token(woosh.NAME, 'modes', 1464, 23, 1464, 28),
woosh.Token(woosh.OP, ':', 1464, 28, 1464, 29),
woosh.Token(woosh.NEWLINE, '\r\n', 1464, 29, 1465, 0),
woosh.Token(woosh.INDENT, ' ', 1465, 0, 1465, 12),
woosh.Token(woosh.NAME, 'raise', 1465, 12, 1465, 17),
woosh.Token(woosh.NAME, 'ValueError', 1465, 18, 1465, 28),
woosh.Token(woosh.OP, '(', 1465, 28, 1465, 29),
woosh.Token(woosh.STRING, '"mode must be \'r\', \'a\', \'w\' or \'x\'"', 1465, 29, 1465, 64),
woosh.Token(woosh.OP, ')', 1465, 64, 1465, 65),
woosh.Token(woosh.NEWLINE, '\r\n', 1465, 65, 1466, 0),
woosh.Token(woosh.DEDENT, ' ', 1466, 0, 1466, 8),
woosh.Token(woosh.NAME, 'self', 1466, 8, 1466, 12),
woosh.Token(woosh.OP, '.', 1466, 12, 1466, 13),
woosh.Token(woosh.NAME, 'mode', 1466, 13, 1466, 17),
woosh.Token(woosh.OP, '=', 1466, 18, 1466, 19),
woosh.Token(woosh.NAME, 'mode', 1466, 20, 1466, 24),
woosh.Token(woosh.NEWLINE, '\r\n', 1466, 24, 1467, 0),
woosh.Token(woosh.NAME, 'self', 1467, 8, 1467, 12),
woosh.Token(woosh.OP, '.', 1467, 12, 1467, 13),
woosh.Token(woosh.NAME, '_mode', 1467, 13, 1467, 18),
woosh.Token(woosh.OP, '=', 1467, 19, 1467, 20),
woosh.Token(woosh.NAME, 'modes', 1467, 21, 1467, 26),
woosh.Token(woosh.OP, '[', 1467, 26, 1467, 27),
woosh.Token(woosh.NAME, 'mode', 1467, 27, 1467, 31),
woosh.Token(woosh.OP, ']', 1467, 31, 1467, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 1467, 32, 1468, 0),
woosh.Token(woosh.NAME, 'if', 1469, 8, 1469, 10),
woosh.Token(woosh.NAME, 'not', 1469, 11, 1469, 14),
woosh.Token(woosh.NAME, 'fileobj', 1469, 15, 1469, 22),
woosh.Token(woosh.OP, ':', 1469, 22, 1469, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 1469, 23, 1470, 0),
woosh.Token(woosh.INDENT, ' ', 1470, 0, 1470, 12),
woosh.Token(woosh.NAME, 'if', 1470, 12, 1470, 14),
woosh.Token(woosh.NAME, 'self', 1470, 15, 1470, 19),
woosh.Token(woosh.OP, '.', 1470, 19, 1470, 20),
woosh.Token(woosh.NAME, 'mode', 1470, 20, 1470, 24),
woosh.Token(woosh.OP, '==', 1470, 25, 1470, 27),
woosh.Token(woosh.STRING, '"a"', 1470, 28, 1470, 31),
woosh.Token(woosh.NAME, 'and', 1470, 32, 1470, 35),
woosh.Token(woosh.NAME, 'not', 1470, 36, 1470, 39),
woosh.Token(woosh.NAME, 'os', 1470, 40, 1470, 42),
woosh.Token(woosh.OP, '.', 1470, 42, 1470, 43),
woosh.Token(woosh.NAME, 'path', 1470, 43, 1470, 47),
woosh.Token(woosh.OP, '.', 1470, 47, 1470, 48),
woosh.Token(woosh.NAME, 'exists', 1470, 48, 1470, 54),
woosh.Token(woosh.OP, '(', 1470, 54, 1470, 55),
woosh.Token(woosh.NAME, 'name', 1470, 55, 1470, 59),
woosh.Token(woosh.OP, ')', 1470, 59, 1470, 60),
woosh.Token(woosh.OP, ':', 1470, 60, 1470, 61),
woosh.Token(woosh.NEWLINE, '\r\n', 1470, 61, 1471, 0),
woosh.Token(woosh.COMMENT, '# Create nonexistent files in append mode.', 1471, 16, 1471, 58),
woosh.Token(woosh.INDENT, ' ', 1472, 0, 1472, 16),
woosh.Token(woosh.NAME, 'self', 1472, 16, 1472, 20),
woosh.Token(woosh.OP, '.', 1472, 20, 1472, 21),
woosh.Token(woosh.NAME, 'mode', 1472, 21, 1472, 25),
woosh.Token(woosh.OP, '=', 1472, 26, 1472, 27),
woosh.Token(woosh.STRING, '"w"', 1472, 28, 1472, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 1472, 31, 1473, 0),
woosh.Token(woosh.NAME, 'self', 1473, 16, 1473, 20),
woosh.Token(woosh.OP, '.', 1473, 20, 1473, 21),
woosh.Token(woosh.NAME, '_mode', 1473, 21, 1473, 26),
woosh.Token(woosh.OP, '=', 1473, 27, 1473, 28),
woosh.Token(woosh.STRING, '"wb"', 1473, 29, 1473, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 1473, 33, 1474, 0),
woosh.Token(woosh.DEDENT, ' ', 1474, 0, 1474, 12),
woosh.Token(woosh.NAME, 'fileobj', 1474, 12, 1474, 19),
woosh.Token(woosh.OP, '=', 1474, 20, 1474, 21),
woosh.Token(woosh.NAME, 'bltn_open', 1474, 22, 1474, 31),
woosh.Token(woosh.OP, '(', 1474, 31, 1474, 32),
woosh.Token(woosh.NAME, 'name', 1474, 32, 1474, 36),
woosh.Token(woosh.OP, ',', 1474, 36, 1474, 37),
woosh.Token(woosh.NAME, 'self', 1474, 38, 1474, 42),
woosh.Token(woosh.OP, '.', 1474, 42, 1474, 43),
woosh.Token(woosh.NAME, '_mode', 1474, 43, 1474, 48),
woosh.Token(woosh.OP, ')', 1474, 48, 1474, 49),
woosh.Token(woosh.NEWLINE, '\r\n', 1474, 49, 1475, 0),
woosh.Token(woosh.NAME, 'self', 1475, 12, 1475, 16),
woosh.Token(woosh.OP, '.', 1475, 16, 1475, 17),
woosh.Token(woosh.NAME, '_extfileobj', 1475, 17, 1475, 28),
woosh.Token(woosh.OP, '=', 1475, 29, 1475, 30),
woosh.Token(woosh.NAME, 'False', 1475, 31, 1475, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 1475, 36, 1476, 0),
woosh.Token(woosh.DEDENT, ' ', 1476, 0, 1476, 8),
woosh.Token(woosh.NAME, 'else', 1476, 8, 1476, 12),
woosh.Token(woosh.OP, ':', 1476, 12, 1476, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 1476, 13, 1477, 0),
woosh.Token(woosh.INDENT, ' ', 1477, 0, 1477, 12),
woosh.Token(woosh.NAME, 'if', 1477, 12, 1477, 14),
woosh.Token(woosh.OP, '(', 1477, 15, 1477, 16),
woosh.Token(woosh.NAME, 'name', 1477, 16, 1477, 20),
woosh.Token(woosh.NAME, 'is', 1477, 21, 1477, 23),
woosh.Token(woosh.NAME, 'None', 1477, 24, 1477, 28),
woosh.Token(woosh.NAME, 'and', 1477, 29, 1477, 32),
woosh.Token(woosh.NAME, 'hasattr', 1477, 33, 1477, 40),
woosh.Token(woosh.OP, '(', 1477, 40, 1477, 41),
woosh.Token(woosh.NAME, 'fileobj', 1477, 41, 1477, 48),
woosh.Token(woosh.OP, ',', 1477, 48, 1477, 49),
woosh.Token(woosh.STRING, '"name"', 1477, 50, 1477, 56),
woosh.Token(woosh.OP, ')', 1477, 56, 1477, 57),
woosh.Token(woosh.NAME, 'and', 1477, 58, 1477, 61),
woosh.Token(woosh.NAME, 'isinstance', 1478, 16, 1478, 26),
woosh.Token(woosh.OP, '(', 1478, 26, 1478, 27),
woosh.Token(woosh.NAME, 'fileobj', 1478, 27, 1478, 34),
woosh.Token(woosh.OP, '.', 1478, 34, 1478, 35),
woosh.Token(woosh.NAME, 'name', 1478, 35, 1478, 39),
woosh.Token(woosh.OP, ',', 1478, 39, 1478, 40),
woosh.Token(woosh.OP, '(', 1478, 41, 1478, 42),
woosh.Token(woosh.NAME, 'str', 1478, 42, 1478, 45),
woosh.Token(woosh.OP, ',', 1478, 45, 1478, 46),
woosh.Token(woosh.NAME, 'bytes', 1478, 47, 1478, 52),
woosh.Token(woosh.OP, ')', 1478, 52, 1478, 53),
woosh.Token(woosh.OP, ')', 1478, 53, 1478, 54),
woosh.Token(woosh.OP, ')', 1478, 54, 1478, 55),
woosh.Token(woosh.OP, ':', 1478, 55, 1478, 56),
woosh.Token(woosh.NEWLINE, '\r\n', 1478, 56, 1479, 0),
woosh.Token(woosh.INDENT, ' ', 1479, 0, 1479, 16),
woosh.Token(woosh.NAME, 'name', 1479, 16, 1479, 20),
woosh.Token(woosh.OP, '=', 1479, 21, 1479, 22),
woosh.Token(woosh.NAME, 'fileobj', 1479, 23, 1479, 30),
woosh.Token(woosh.OP, '.', 1479, 30, 1479, 31),
woosh.Token(woosh.NAME, 'name', 1479, 31, 1479, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 1479, 35, 1480, 0),
woosh.Token(woosh.DEDENT, ' ', 1480, 0, 1480, 12),
woosh.Token(woosh.NAME, 'if', 1480, 12, 1480, 14),
woosh.Token(woosh.NAME, 'hasattr', 1480, 15, 1480, 22),
woosh.Token(woosh.OP, '(', 1480, 22, 1480, 23),
woosh.Token(woosh.NAME, 'fileobj', 1480, 23, 1480, 30),
woosh.Token(woosh.OP, ',', 1480, 30, 1480, 31),
woosh.Token(woosh.STRING, '"mode"', 1480, 32, 1480, 38),
woosh.Token(woosh.OP, ')', 1480, 38, 1480, 39),
woosh.Token(woosh.OP, ':', 1480, 39, 1480, 40),
woosh.Token(woosh.NEWLINE, '\r\n', 1480, 40, 1481, 0),
woosh.Token(woosh.INDENT, ' ', 1481, 0, 1481, 16),
woosh.Token(woosh.NAME, 'self', 1481, 16, 1481, 20),
woosh.Token(woosh.OP, '.', 1481, 20, 1481, 21),
woosh.Token(woosh.NAME, '_mode', 1481, 21, 1481, 26),
woosh.Token(woosh.OP, '=', 1481, 27, 1481, 28),
woosh.Token(woosh.NAME, 'fileobj', 1481, 29, 1481, 36),
woosh.Token(woosh.OP, '.', 1481, 36, 1481, 37),
woosh.Token(woosh.NAME, 'mode', 1481, 37, 1481, 41),
woosh.Token(woosh.NEWLINE, '\r\n', 1481, 41, 1482, 0),
woosh.Token(woosh.DEDENT, ' ', 1482, 0, 1482, 12),
woosh.Token(woosh.NAME, 'self', 1482, 12, 1482, 16),
woosh.Token(woosh.OP, '.', 1482, 16, 1482, 17),
woosh.Token(woosh.NAME, '_extfileobj', 1482, 17, 1482, 28),
woosh.Token(woosh.OP, '=', 1482, 29, 1482, 30),
woosh.Token(woosh.NAME, 'True', 1482, 31, 1482, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 1482, 35, 1483, 0),
woosh.Token(woosh.DEDENT, ' ', 1483, 0, 1483, 8),
woosh.Token(woosh.NAME, 'self', 1483, 8, 1483, 12),
woosh.Token(woosh.OP, '.', 1483, 12, 1483, 13),
woosh.Token(woosh.NAME, 'name', 1483, 13, 1483, 17),
woosh.Token(woosh.OP, '=', 1483, 18, 1483, 19),
woosh.Token(woosh.NAME, 'os', 1483, 20, 1483, 22),
woosh.Token(woosh.OP, '.', 1483, 22, 1483, 23),
woosh.Token(woosh.NAME, 'path', 1483, 23, 1483, 27),
woosh.Token(woosh.OP, '.', 1483, 27, 1483, 28),
woosh.Token(woosh.NAME, 'abspath', 1483, 28, 1483, 35),
woosh.Token(woosh.OP, '(', 1483, 35, 1483, 36),
woosh.Token(woosh.NAME, 'name', 1483, 36, 1483, 40),
woosh.Token(woosh.OP, ')', 1483, 40, 1483, 41),
woosh.Token(woosh.NAME, 'if', 1483, 42, 1483, 44),
woosh.Token(woosh.NAME, 'name', 1483, 45, 1483, 49),
woosh.Token(woosh.NAME, 'else', 1483, 50, 1483, 54),
woosh.Token(woosh.NAME, 'None', 1483, 55, 1483, 59),
woosh.Token(woosh.NEWLINE, '\r\n', 1483, 59, 1484, 0),
woosh.Token(woosh.NAME, 'self', 1484, 8, 1484, 12),
woosh.Token(woosh.OP, '.', 1484, 12, 1484, 13),
woosh.Token(woosh.NAME, 'fileobj', 1484, 13, 1484, 20),
woosh.Token(woosh.OP, '=', 1484, 21, 1484, 22),
woosh.Token(woosh.NAME, 'fileobj', 1484, 23, 1484, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 1484, 30, 1485, 0),
woosh.Token(woosh.COMMENT, '# Init attributes.', 1486, 8, 1486, 26),
woosh.Token(woosh.NAME, 'if', 1487, 8, 1487, 10),
woosh.Token(woosh.NAME, 'format', 1487, 11, 1487, 17),
woosh.Token(woosh.NAME, 'is', 1487, 18, 1487, 20),
woosh.Token(woosh.NAME, 'not', 1487, 21, 1487, 24),
woosh.Token(woosh.NAME, 'None', 1487, 25, 1487, 29),
woosh.Token(woosh.OP, ':', 1487, 29, 1487, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 1487, 30, 1488, 0),
woosh.Token(woosh.INDENT, ' ', 1488, 0, 1488, 12),
woosh.Token(woosh.NAME, 'self', 1488, 12, 1488, 16),
woosh.Token(woosh.OP, '.', 1488, 16, 1488, 17),
woosh.Token(woosh.NAME, 'format', 1488, 17, 1488, 23),
woosh.Token(woosh.OP, '=', 1488, 24, 1488, 25),
woosh.Token(woosh.NAME, 'format', 1488, 26, 1488, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 1488, 32, 1489, 0),
woosh.Token(woosh.DEDENT, ' ', 1489, 0, 1489, 8),
woosh.Token(woosh.NAME, 'if', 1489, 8, 1489, 10),
woosh.Token(woosh.NAME, 'tarinfo', 1489, 11, 1489, 18),
woosh.Token(woosh.NAME, 'is', 1489, 19, 1489, 21),
woosh.Token(woosh.NAME, 'not', 1489, 22, 1489, 25),
woosh.Token(woosh.NAME, 'None', 1489, 26, 1489, 30),
woosh.Token(woosh.OP, ':', 1489, 30, 1489, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 1489, 31, 1490, 0),
woosh.Token(woosh.INDENT, ' ', 1490, 0, 1490, 12),
woosh.Token(woosh.NAME, 'self', 1490, 12, 1490, 16),
woosh.Token(woosh.OP, '.', 1490, 16, 1490, 17),
woosh.Token(woosh.NAME, 'tarinfo', 1490, 17, 1490, 24),
woosh.Token(woosh.OP, '=', 1490, 25, 1490, 26),
woosh.Token(woosh.NAME, 'tarinfo', 1490, 27, 1490, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 1490, 34, 1491, 0),
woosh.Token(woosh.DEDENT, ' ', 1491, 0, 1491, 8),
woosh.Token(woosh.NAME, 'if', 1491, 8, 1491, 10),
woosh.Token(woosh.NAME, 'dereference', 1491, 11, 1491, 22),
woosh.Token(woosh.NAME, 'is', 1491, 23, 1491, 25),
woosh.Token(woosh.NAME, 'not', 1491, 26, 1491, 29),
woosh.Token(woosh.NAME, 'None', 1491, 30, 1491, 34),
woosh.Token(woosh.OP, ':', 1491, 34, 1491, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 1491, 35, 1492, 0),
woosh.Token(woosh.INDENT, ' ', 1492, 0, 1492, 12),
woosh.Token(woosh.NAME, 'self', 1492, 12, 1492, 16),
woosh.Token(woosh.OP, '.', 1492, 16, 1492, 17),
woosh.Token(woosh.NAME, 'dereference', 1492, 17, 1492, 28),
woosh.Token(woosh.OP, '=', 1492, 29, 1492, 30),
woosh.Token(woosh.NAME, 'dereference', 1492, 31, 1492, 42),
woosh.Token(woosh.NEWLINE, '\r\n', 1492, 42, 1493, 0),
woosh.Token(woosh.DEDENT, ' ', 1493, 0, 1493, 8),
woosh.Token(woosh.NAME, 'if', 1493, 8, 1493, 10),
woosh.Token(woosh.NAME, 'ignore_zeros', 1493, 11, 1493, 23),
woosh.Token(woosh.NAME, 'is', 1493, 24, 1493, 26),
woosh.Token(woosh.NAME, 'not', 1493, 27, 1493, 30),
woosh.Token(woosh.NAME, 'None', 1493, 31, 1493, 35),
woosh.Token(woosh.OP, ':', 1493, 35, 1493, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 1493, 36, 1494, 0),
woosh.Token(woosh.INDENT, ' ', 1494, 0, 1494, 12),
woosh.Token(woosh.NAME, 'self', 1494, 12, 1494, 16),
woosh.Token(woosh.OP, '.', 1494, 16, 1494, 17),
woosh.Token(woosh.NAME, 'ignore_zeros', 1494, 17, 1494, 29),
woosh.Token(woosh.OP, '=', 1494, 30, 1494, 31),
woosh.Token(woosh.NAME, 'ignore_zeros', 1494, 32, 1494, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 1494, 44, 1495, 0),
woosh.Token(woosh.DEDENT, ' ', 1495, 0, 1495, 8),
woosh.Token(woosh.NAME, 'if', 1495, 8, 1495, 10),
woosh.Token(woosh.NAME, 'encoding', 1495, 11, 1495, 19),
woosh.Token(woosh.NAME, 'is', 1495, 20, 1495, 22),
woosh.Token(woosh.NAME, 'not', 1495, 23, 1495, 26),
woosh.Token(woosh.NAME, 'None', 1495, 27, 1495, 31),
woosh.Token(woosh.OP, ':', 1495, 31, 1495, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 1495, 32, 1496, 0),
woosh.Token(woosh.INDENT, ' ', 1496, 0, 1496, 12),
woosh.Token(woosh.NAME, 'self', 1496, 12, 1496, 16),
woosh.Token(woosh.OP, '.', 1496, 16, 1496, 17),
woosh.Token(woosh.NAME, 'encoding', 1496, 17, 1496, 25),
woosh.Token(woosh.OP, '=', 1496, 26, 1496, 27),
woosh.Token(woosh.NAME, 'encoding', 1496, 28, 1496, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 1496, 36, 1497, 0),
woosh.Token(woosh.DEDENT, ' ', 1497, 0, 1497, 8),
woosh.Token(woosh.NAME, 'self', 1497, 8, 1497, 12),
woosh.Token(woosh.OP, '.', 1497, 12, 1497, 13),
woosh.Token(woosh.NAME, 'errors', 1497, 13, 1497, 19),
woosh.Token(woosh.OP, '=', 1497, 20, 1497, 21),
woosh.Token(woosh.NAME, 'errors', 1497, 22, 1497, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 1497, 28, 1498, 0),
woosh.Token(woosh.NAME, 'if', 1499, 8, 1499, 10),
woosh.Token(woosh.NAME, 'pax_headers', 1499, 11, 1499, 22),
woosh.Token(woosh.NAME, 'is', 1499, 23, 1499, 25),
woosh.Token(woosh.NAME, 'not', 1499, 26, 1499, 29),
woosh.Token(woosh.NAME, 'None', 1499, 30, 1499, 34),
woosh.Token(woosh.NAME, 'and', 1499, 35, 1499, 38),
woosh.Token(woosh.NAME, 'self', 1499, 39, 1499, 43),
woosh.Token(woosh.OP, '.', 1499, 43, 1499, 44),
woosh.Token(woosh.NAME, 'format', 1499, 44, 1499, 50),
woosh.Token(woosh.OP, '==', 1499, 51, 1499, 53),
woosh.Token(woosh.NAME, 'PAX_FORMAT', 1499, 54, 1499, 64),
woosh.Token(woosh.OP, ':', 1499, 64, 1499, 65),
woosh.Token(woosh.NEWLINE, '\r\n', 1499, 65, 1500, 0),
woosh.Token(woosh.INDENT, ' ', 1500, 0, 1500, 12),
woosh.Token(woosh.NAME, 'self', 1500, 12, 1500, 16),
woosh.Token(woosh.OP, '.', 1500, 16, 1500, 17),
woosh.Token(woosh.NAME, 'pax_headers', 1500, 17, 1500, 28),
woosh.Token(woosh.OP, '=', 1500, 29, 1500, 30),
woosh.Token(woosh.NAME, 'pax_headers', 1500, 31, 1500, 42),
woosh.Token(woosh.NEWLINE, '\r\n', 1500, 42, 1501, 0),
woosh.Token(woosh.DEDENT, ' ', 1501, 0, 1501, 8),
woosh.Token(woosh.NAME, 'else', 1501, 8, 1501, 12),
woosh.Token(woosh.OP, ':', 1501, 12, 1501, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 1501, 13, 1502, 0),
woosh.Token(woosh.INDENT, ' ', 1502, 0, 1502, 12),
woosh.Token(woosh.NAME, 'self', 1502, 12, 1502, 16),
woosh.Token(woosh.OP, '.', 1502, 16, 1502, 17),
woosh.Token(woosh.NAME, 'pax_headers', 1502, 17, 1502, 28),
woosh.Token(woosh.OP, '=', 1502, 29, 1502, 30),
woosh.Token(woosh.OP, '{', 1502, 31, 1502, 32),
woosh.Token(woosh.OP, '}', 1502, 32, 1502, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 1502, 33, 1503, 0),
woosh.Token(woosh.DEDENT, ' ', 1504, 0, 1504, 8),
woosh.Token(woosh.NAME, 'if', 1504, 8, 1504, 10),
woosh.Token(woosh.NAME, 'debug', 1504, 11, 1504, 16),
woosh.Token(woosh.NAME, 'is', 1504, 17, 1504, 19),
woosh.Token(woosh.NAME, 'not', 1504, 20, 1504, 23),
woosh.Token(woosh.NAME, 'None', 1504, 24, 1504, 28),
woosh.Token(woosh.OP, ':', 1504, 28, 1504, 29),
woosh.Token(woosh.NEWLINE, '\r\n', 1504, 29, 1505, 0),
woosh.Token(woosh.INDENT, ' ', 1505, 0, 1505, 12),
woosh.Token(woosh.NAME, 'self', 1505, 12, 1505, 16),
woosh.Token(woosh.OP, '.', 1505, 16, 1505, 17),
woosh.Token(woosh.NAME, 'debug', 1505, 17, 1505, 22),
woosh.Token(woosh.OP, '=', 1505, 23, 1505, 24),
woosh.Token(woosh.NAME, 'debug', 1505, 25, 1505, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 1505, 30, 1506, 0),
woosh.Token(woosh.DEDENT, ' ', 1506, 0, 1506, 8),
woosh.Token(woosh.NAME, 'if', 1506, 8, 1506, 10),
woosh.Token(woosh.NAME, 'errorlevel', 1506, 11, 1506, 21),
woosh.Token(woosh.NAME, 'is', 1506, 22, 1506, 24),
woosh.Token(woosh.NAME, 'not', 1506, 25, 1506, 28),
woosh.Token(woosh.NAME, 'None', 1506, 29, 1506, 33),
woosh.Token(woosh.OP, ':', 1506, 33, 1506, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 1506, 34, 1507, 0),
woosh.Token(woosh.INDENT, ' ', 1507, 0, 1507, 12),
woosh.Token(woosh.NAME, 'self', 1507, 12, 1507, 16),
woosh.Token(woosh.OP, '.', 1507, 16, 1507, 17),
woosh.Token(woosh.NAME, 'errorlevel', 1507, 17, 1507, 27),
woosh.Token(woosh.OP, '=', 1507, 28, 1507, 29),
woosh.Token(woosh.NAME, 'errorlevel', 1507, 30, 1507, 40),
woosh.Token(woosh.NEWLINE, '\r\n', 1507, 40, 1508, 0),
woosh.Token(woosh.COMMENT, '# Init datastructures.', 1509, 8, 1509, 30),
woosh.Token(woosh.DEDENT, ' ', 1510, 0, 1510, 8),
woosh.Token(woosh.NAME, 'self', 1510, 8, 1510, 12),
woosh.Token(woosh.OP, '.', 1510, 12, 1510, 13),
woosh.Token(woosh.NAME, 'copybufsize', 1510, 13, 1510, 24),
woosh.Token(woosh.OP, '=', 1510, 25, 1510, 26),
woosh.Token(woosh.NAME, 'copybufsize', 1510, 27, 1510, 38),
woosh.Token(woosh.NEWLINE, '\r\n', 1510, 38, 1511, 0),
woosh.Token(woosh.NAME, 'self', 1511, 8, 1511, 12),
woosh.Token(woosh.OP, '.', 1511, 12, 1511, 13),
woosh.Token(woosh.NAME, 'closed', 1511, 13, 1511, 19),
woosh.Token(woosh.OP, '=', 1511, 20, 1511, 21),
woosh.Token(woosh.NAME, 'False', 1511, 22, 1511, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 1511, 27, 1512, 0),
woosh.Token(woosh.NAME, 'self', 1512, 8, 1512, 12),
woosh.Token(woosh.OP, '.', 1512, 12, 1512, 13),
woosh.Token(woosh.NAME, 'members', 1512, 13, 1512, 20),
woosh.Token(woosh.OP, '=', 1512, 21, 1512, 22),
woosh.Token(woosh.OP, '[', 1512, 23, 1512, 24),
woosh.Token(woosh.OP, ']', 1512, 24, 1512, 25),
woosh.Token(woosh.COMMENT, '# list of members as TarInfo objects', 1512, 32, 1512, 68),
woosh.Token(woosh.NEWLINE, '\r\n', 1512, 68, 1513, 0),
woosh.Token(woosh.NAME, 'self', 1513, 8, 1513, 12),
woosh.Token(woosh.OP, '.', 1513, 12, 1513, 13),
woosh.Token(woosh.NAME, '_loaded', 1513, 13, 1513, 20),
woosh.Token(woosh.OP, '=', 1513, 21, 1513, 22),
woosh.Token(woosh.NAME, 'False', 1513, 23, 1513, 28),
woosh.Token(woosh.COMMENT, '# flag if all members have been read', 1513, 32, 1513, 68),
woosh.Token(woosh.NEWLINE, '\r\n', 1513, 68, 1514, 0),
woosh.Token(woosh.NAME, 'self', 1514, 8, 1514, 12),
woosh.Token(woosh.OP, '.', 1514, 12, 1514, 13),
woosh.Token(woosh.NAME, 'offset', 1514, 13, 1514, 19),
woosh.Token(woosh.OP, '=', 1514, 20, 1514, 21),
woosh.Token(woosh.NAME, 'self', 1514, 22, 1514, 26),
woosh.Token(woosh.OP, '.', 1514, 26, 1514, 27),
woosh.Token(woosh.NAME, 'fileobj', 1514, 27, 1514, 34),
woosh.Token(woosh.OP, '.', 1514, 34, 1514, 35),
woosh.Token(woosh.NAME, 'tell', 1514, 35, 1514, 39),
woosh.Token(woosh.OP, '(', 1514, 39, 1514, 40),
woosh.Token(woosh.OP, ')', 1514, 40, 1514, 41),
woosh.Token(woosh.NEWLINE, '\r\n', 1514, 41, 1515, 0),
woosh.Token(woosh.COMMENT, '# current position in the archive file', 1515, 32, 1515, 70),
woosh.Token(woosh.NAME, 'self', 1516, 8, 1516, 12),
woosh.Token(woosh.OP, '.', 1516, 12, 1516, 13),
woosh.Token(woosh.NAME, 'inodes', 1516, 13, 1516, 19),
woosh.Token(woosh.OP, '=', 1516, 20, 1516, 21),
woosh.Token(woosh.OP, '{', 1516, 22, 1516, 23),
woosh.Token(woosh.OP, '}', 1516, 23, 1516, 24),
woosh.Token(woosh.COMMENT, '# dictionary caching the inodes of', 1516, 32, 1516, 66),
woosh.Token(woosh.NEWLINE, '\r\n', 1516, 66, 1517, 0),
woosh.Token(woosh.COMMENT, '# archive members already added', 1517, 32, 1517, 63),
woosh.Token(woosh.NAME, 'try', 1519, 8, 1519, 11),
woosh.Token(woosh.OP, ':', 1519, 11, 1519, 12),
woosh.Token(woosh.NEWLINE, '\r\n', 1519, 12, 1520, 0),
woosh.Token(woosh.INDENT, ' ', 1520, 0, 1520, 12),
woosh.Token(woosh.NAME, 'if', 1520, 12, 1520, 14),
woosh.Token(woosh.NAME, 'self', 1520, 15, 1520, 19),
woosh.Token(woosh.OP, '.', 1520, 19, 1520, 20),
woosh.Token(woosh.NAME, 'mode', 1520, 20, 1520, 24),
woosh.Token(woosh.OP, '==', 1520, 25, 1520, 27),
woosh.Token(woosh.STRING, '"r"', 1520, 28, 1520, 31),
woosh.Token(woosh.OP, ':', 1520, 31, 1520, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 1520, 32, 1521, 0),
woosh.Token(woosh.INDENT, ' ', 1521, 0, 1521, 16),
woosh.Token(woosh.NAME, 'self', 1521, 16, 1521, 20),
woosh.Token(woosh.OP, '.', 1521, 20, 1521, 21),
woosh.Token(woosh.NAME, 'firstmember', 1521, 21, 1521, 32),
woosh.Token(woosh.OP, '=', 1521, 33, 1521, 34),
woosh.Token(woosh.NAME, 'None', 1521, 35, 1521, 39),
woosh.Token(woosh.NEWLINE, '\r\n', 1521, 39, 1522, 0),
woosh.Token(woosh.NAME, 'self', 1522, 16, 1522, 20),
woosh.Token(woosh.OP, '.', 1522, 20, 1522, 21),
woosh.Token(woosh.NAME, 'firstmember', 1522, 21, 1522, 32),
woosh.Token(woosh.OP, '=', 1522, 33, 1522, 34),
woosh.Token(woosh.NAME, 'self', 1522, 35, 1522, 39),
woosh.Token(woosh.OP, '.', 1522, 39, 1522, 40),
woosh.Token(woosh.NAME, 'next', 1522, 40, 1522, 44),
woosh.Token(woosh.OP, '(', 1522, 44, 1522, 45),
woosh.Token(woosh.OP, ')', 1522, 45, 1522, 46),
woosh.Token(woosh.NEWLINE, '\r\n', 1522, 46, 1523, 0),
woosh.Token(woosh.DEDENT, ' ', 1524, 0, 1524, 12),
woosh.Token(woosh.NAME, 'if', 1524, 12, 1524, 14),
woosh.Token(woosh.NAME, 'self', 1524, 15, 1524, 19),
woosh.Token(woosh.OP, '.', 1524, 19, 1524, 20),
woosh.Token(woosh.NAME, 'mode', 1524, 20, 1524, 24),
woosh.Token(woosh.OP, '==', 1524, 25, 1524, 27),
woosh.Token(woosh.STRING, '"a"', 1524, 28, 1524, 31),
woosh.Token(woosh.OP, ':', 1524, 31, 1524, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 1524, 32, 1525, 0),
woosh.Token(woosh.COMMENT, '# Move to the end of the archive,', 1525, 16, 1525, 49),
woosh.Token(woosh.COMMENT, '# before the first empty block.', 1526, 16, 1526, 47),
woosh.Token(woosh.INDENT, ' ', 1527, 0, 1527, 16),
woosh.Token(woosh.NAME, 'while', 1527, 16, 1527, 21),
woosh.Token(woosh.NAME, 'True', 1527, 22, 1527, 26),
woosh.Token(woosh.OP, ':', 1527, 26, 1527, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 1527, 27, 1528, 0),
woosh.Token(woosh.INDENT, ' ', 1528, 0, 1528, 20),
woosh.Token(woosh.NAME, 'self', 1528, 20, 1528, 24),
woosh.Token(woosh.OP, '.', 1528, 24, 1528, 25),
woosh.Token(woosh.NAME, 'fileobj', 1528, 25, 1528, 32),
woosh.Token(woosh.OP, '.', 1528, 32, 1528, 33),
woosh.Token(woosh.NAME, 'seek', 1528, 33, 1528, 37),
woosh.Token(woosh.OP, '(', 1528, 37, 1528, 38),
woosh.Token(woosh.NAME, 'self', 1528, 38, 1528, 42),
woosh.Token(woosh.OP, '.', 1528, 42, 1528, 43),
woosh.Token(woosh.NAME, 'offset', 1528, 43, 1528, 49),
woosh.Token(woosh.OP, ')', 1528, 49, 1528, 50),
woosh.Token(woosh.NEWLINE, '\r\n', 1528, 50, 1529, 0),
woosh.Token(woosh.NAME, 'try', 1529, 20, 1529, 23),
woosh.Token(woosh.OP, ':', 1529, 23, 1529, 24),
woosh.Token(woosh.NEWLINE, '\r\n', 1529, 24, 1530, 0),
woosh.Token(woosh.INDENT, ' ', 1530, 0, 1530, 24),
woosh.Token(woosh.NAME, 'tarinfo', 1530, 24, 1530, 31),
woosh.Token(woosh.OP, '=', 1530, 32, 1530, 33),
woosh.Token(woosh.NAME, 'self', 1530, 34, 1530, 38),
woosh.Token(woosh.OP, '.', 1530, 38, 1530, 39),
woosh.Token(woosh.NAME, 'tarinfo', 1530, 39, 1530, 46),
woosh.Token(woosh.OP, '.', 1530, 46, 1530, 47),
woosh.Token(woosh.NAME, 'fromtarfile', 1530, 47, 1530, 58),
woosh.Token(woosh.OP, '(', 1530, 58, 1530, 59),
woosh.Token(woosh.NAME, 'self', 1530, 59, 1530, 63),
woosh.Token(woosh.OP, ')', 1530, 63, 1530, 64),
woosh.Token(woosh.NEWLINE, '\r\n', 1530, 64, 1531, 0),
woosh.Token(woosh.NAME, 'self', 1531, 24, 1531, 28),
woosh.Token(woosh.OP, '.', 1531, 28, 1531, 29),
woosh.Token(woosh.NAME, 'members', 1531, 29, 1531, 36),
woosh.Token(woosh.OP, '.', 1531, 36, 1531, 37),
woosh.Token(woosh.NAME, 'append', 1531, 37, 1531, 43),
woosh.Token(woosh.OP, '(', 1531, 43, 1531, 44),
woosh.Token(woosh.NAME, 'tarinfo', 1531, 44, 1531, 51),
woosh.Token(woosh.OP, ')', 1531, 51, 1531, 52),
woosh.Token(woosh.NEWLINE, '\r\n', 1531, 52, 1532, 0),
woosh.Token(woosh.DEDENT, ' ', 1532, 0, 1532, 20),
woosh.Token(woosh.NAME, 'except', 1532, 20, 1532, 26),
woosh.Token(woosh.NAME, 'EOFHeaderError', 1532, 27, 1532, 41),
woosh.Token(woosh.OP, ':', 1532, 41, 1532, 42),
woosh.Token(woosh.NEWLINE, '\r\n', 1532, 42, 1533, 0),
woosh.Token(woosh.INDENT, ' ', 1533, 0, 1533, 24),
woosh.Token(woosh.NAME, 'self', 1533, 24, 1533, 28),
woosh.Token(woosh.OP, '.', 1533, 28, 1533, 29),
woosh.Token(woosh.NAME, 'fileobj', 1533, 29, 1533, 36),
woosh.Token(woosh.OP, '.', 1533, 36, 1533, 37),
woosh.Token(woosh.NAME, 'seek', 1533, 37, 1533, 41),
woosh.Token(woosh.OP, '(', 1533, 41, 1533, 42),
woosh.Token(woosh.NAME, 'self', 1533, 42, 1533, 46),
woosh.Token(woosh.OP, '.', 1533, 46, 1533, 47),
woosh.Token(woosh.NAME, 'offset', 1533, 47, 1533, 53),
woosh.Token(woosh.OP, ')', 1533, 53, 1533, 54),
woosh.Token(woosh.NEWLINE, '\r\n', 1533, 54, 1534, 0),
woosh.Token(woosh.NAME, 'break', 1534, 24, 1534, 29),
woosh.Token(woosh.NEWLINE, '\r\n', 1534, 29, 1535, 0),
woosh.Token(woosh.DEDENT, ' ', 1535, 0, 1535, 20),
woosh.Token(woosh.NAME, 'except', 1535, 20, 1535, 26),
woosh.Token(woosh.NAME, 'HeaderError', 1535, 27, 1535, 38),
woosh.Token(woosh.NAME, 'as', 1535, 39, 1535, 41),
woosh.Token(woosh.NAME, 'e', 1535, 42, 1535, 43),
woosh.Token(woosh.OP, ':', 1535, 43, 1535, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 1535, 44, 1536, 0),
woosh.Token(woosh.INDENT, ' ', 1536, 0, 1536, 24),
woosh.Token(woosh.NAME, 'raise', 1536, 24, 1536, 29),
woosh.Token(woosh.NAME, 'ReadError', 1536, 30, 1536, 39),
woosh.Token(woosh.OP, '(', 1536, 39, 1536, 40),
woosh.Token(woosh.NAME, 'str', 1536, 40, 1536, 43),
woosh.Token(woosh.OP, '(', 1536, 43, 1536, 44),
woosh.Token(woosh.NAME, 'e', 1536, 44, 1536, 45),
woosh.Token(woosh.OP, ')', 1536, 45, 1536, 46),
woosh.Token(woosh.OP, ')', 1536, 46, 1536, 47),
woosh.Token(woosh.NEWLINE, '\r\n', 1536, 47, 1537, 0),
woosh.Token(woosh.DEDENT, ' ', 1538, 0, 1538, 12),
woosh.Token(woosh.DEDENT, '', 1538, 12, 1538, 12),
woosh.Token(woosh.DEDENT, '', 1538, 12, 1538, 12),
woosh.Token(woosh.NAME, 'if', 1538, 12, 1538, 14),
woosh.Token(woosh.NAME, 'self', 1538, 15, 1538, 19),
woosh.Token(woosh.OP, '.', 1538, 19, 1538, 20),
woosh.Token(woosh.NAME, 'mode', 1538, 20, 1538, 24),
woosh.Token(woosh.NAME, 'in', 1538, 25, 1538, 27),
woosh.Token(woosh.OP, '(', 1538, 28, 1538, 29),
woosh.Token(woosh.STRING, '"a"', 1538, 29, 1538, 32),
woosh.Token(woosh.OP, ',', 1538, 32, 1538, 33),
woosh.Token(woosh.STRING, '"w"', 1538, 34, 1538, 37),
woosh.Token(woosh.OP, ',', 1538, 37, 1538, 38),
woosh.Token(woosh.STRING, '"x"', 1538, 39, 1538, 42),
woosh.Token(woosh.OP, ')', 1538, 42, 1538, 43),
woosh.Token(woosh.OP, ':', 1538, 43, 1538, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 1538, 44, 1539, 0),
woosh.Token(woosh.INDENT, ' ', 1539, 0, 1539, 16),
woosh.Token(woosh.NAME, 'self', 1539, 16, 1539, 20),
woosh.Token(woosh.OP, '.', 1539, 20, 1539, 21),
woosh.Token(woosh.NAME, '_loaded', 1539, 21, 1539, 28),
woosh.Token(woosh.OP, '=', 1539, 29, 1539, 30),
woosh.Token(woosh.NAME, 'True', 1539, 31, 1539, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 1539, 35, 1540, 0),
woosh.Token(woosh.NAME, 'if', 1541, 16, 1541, 18),
woosh.Token(woosh.NAME, 'self', 1541, 19, 1541, 23),
woosh.Token(woosh.OP, '.', 1541, 23, 1541, 24),
woosh.Token(woosh.NAME, 'pax_headers', 1541, 24, 1541, 35),
woosh.Token(woosh.OP, ':', 1541, 35, 1541, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 1541, 36, 1542, 0),
woosh.Token(woosh.INDENT, ' ', 1542, 0, 1542, 20),
woosh.Token(woosh.NAME, 'buf', 1542, 20, 1542, 23),
woosh.Token(woosh.OP, '=', 1542, 24, 1542, 25),
woosh.Token(woosh.NAME, 'self', 1542, 26, 1542, 30),
woosh.Token(woosh.OP, '.', 1542, 30, 1542, 31),
woosh.Token(woosh.NAME, 'tarinfo', 1542, 31, 1542, 38),
woosh.Token(woosh.OP, '.', 1542, 38, 1542, 39),
woosh.Token(woosh.NAME, 'create_pax_global_header', 1542, 39, 1542, 63),
woosh.Token(woosh.OP, '(', 1542, 63, 1542, 64),
woosh.Token(woosh.NAME, 'self', 1542, 64, 1542, 68),
woosh.Token(woosh.OP, '.', 1542, 68, 1542, 69),
woosh.Token(woosh.NAME, 'pax_headers', 1542, 69, 1542, 80),
woosh.Token(woosh.OP, '.', 1542, 80, 1542, 81),
woosh.Token(woosh.NAME, 'copy', 1542, 81, 1542, 85),
woosh.Token(woosh.OP, '(', 1542, 85, 1542, 86),
woosh.Token(woosh.OP, ')', 1542, 86, 1542, 87),
woosh.Token(woosh.OP, ')', 1542, 87, 1542, 88),
woosh.Token(woosh.NEWLINE, '\r\n', 1542, 88, 1543, 0),
woosh.Token(woosh.NAME, 'self', 1543, 20, 1543, 24),
woosh.Token(woosh.OP, '.', 1543, 24, 1543, 25),
woosh.Token(woosh.NAME, 'fileobj', 1543, 25, 1543, 32),
woosh.Token(woosh.OP, '.', 1543, 32, 1543, 33),
woosh.Token(woosh.NAME, 'write', 1543, 33, 1543, 38),
woosh.Token(woosh.OP, '(', 1543, 38, 1543, 39),
woosh.Token(woosh.NAME, 'buf', 1543, 39, 1543, 42),
woosh.Token(woosh.OP, ')', 1543, 42, 1543, 43),
woosh.Token(woosh.NEWLINE, '\r\n', 1543, 43, 1544, 0),
woosh.Token(woosh.NAME, 'self', 1544, 20, 1544, 24),
woosh.Token(woosh.OP, '.', 1544, 24, 1544, 25),
woosh.Token(woosh.NAME, 'offset', 1544, 25, 1544, 31),
woosh.Token(woosh.OP, '+=', 1544, 32, 1544, 34),
woosh.Token(woosh.NAME, 'len', 1544, 35, 1544, 38),
woosh.Token(woosh.OP, '(', 1544, 38, 1544, 39),
woosh.Token(woosh.NAME, 'buf', 1544, 39, 1544, 42),
woosh.Token(woosh.OP, ')', 1544, 42, 1544, 43),
woosh.Token(woosh.NEWLINE, '\r\n', 1544, 43, 1545, 0),
woosh.Token(woosh.DEDENT, ' ', 1545, 0, 1545, 8),
woosh.Token(woosh.DEDENT, '', 1545, 8, 1545, 8),
woosh.Token(woosh.DEDENT, '', 1545, 8, 1545, 8),
woosh.Token(woosh.NAME, 'except', 1545, 8, 1545, 14),
woosh.Token(woosh.OP, ':', 1545, 14, 1545, 15),
woosh.Token(woosh.NEWLINE, '\r\n', 1545, 15, 1546, 0),
woosh.Token(woosh.INDENT, ' ', 1546, 0, 1546, 12),
woosh.Token(woosh.NAME, 'if', 1546, 12, 1546, 14),
woosh.Token(woosh.NAME, 'not', 1546, 15, 1546, 18),
woosh.Token(woosh.NAME, 'self', 1546, 19, 1546, 23),
woosh.Token(woosh.OP, '.', 1546, 23, 1546, 24),
woosh.Token(woosh.NAME, '_extfileobj', 1546, 24, 1546, 35),
woosh.Token(woosh.OP, ':', 1546, 35, 1546, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 1546, 36, 1547, 0),
woosh.Token(woosh.INDENT, ' ', 1547, 0, 1547, 16),
woosh.Token(woosh.NAME, 'self', 1547, 16, 1547, 20),
woosh.Token(woosh.OP, '.', 1547, 20, 1547, 21),
woosh.Token(woosh.NAME, 'fileobj', 1547, 21, 1547, 28),
woosh.Token(woosh.OP, '.', 1547, 28, 1547, 29),
woosh.Token(woosh.NAME, 'close', 1547, 29, 1547, 34),
woosh.Token(woosh.OP, '(', 1547, 34, 1547, 35),
woosh.Token(woosh.OP, ')', 1547, 35, 1547, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 1547, 36, 1548, 0),
woosh.Token(woosh.DEDENT, ' ', 1548, 0, 1548, 12),
woosh.Token(woosh.NAME, 'self', 1548, 12, 1548, 16),
woosh.Token(woosh.OP, '.', 1548, 16, 1548, 17),
woosh.Token(woosh.NAME, 'closed', 1548, 17, 1548, 23),
woosh.Token(woosh.OP, '=', 1548, 24, 1548, 25),
woosh.Token(woosh.NAME, 'True', 1548, 26, 1548, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 1548, 30, 1549, 0),
woosh.Token(woosh.NAME, 'raise', 1549, 12, 1549, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 1549, 17, 1550, 0),
woosh.Token(woosh.COMMENT, '#--------------------------------------------------------------------------', 1551, 4, 1551, 79),
woosh.Token(woosh.COMMENT, '# Below are the classmethods which act as alternate constructors to the', 1552, 4, 1552, 75),
woosh.Token(woosh.COMMENT, '# TarFile class. The open() method is the only one that is needed for', 1553, 4, 1553, 73),
woosh.Token(woosh.COMMENT, '# public use; it is the "super"-constructor and is able to select an', 1554, 4, 1554, 72),
woosh.Token(woosh.COMMENT, '# adequate "sub"-constructor for a particular compression using the mapping', 1555, 4, 1555, 79),
woosh.Token(woosh.COMMENT, '# from OPEN_METH.', 1556, 4, 1556, 21),
woosh.Token(woosh.COMMENT, '#', 1557, 4, 1557, 5),
woosh.Token(woosh.COMMENT, '# This concept allows one to subclass TarFile without losing the comfort of', 1558, 4, 1558, 79),
woosh.Token(woosh.COMMENT, '# the super-constructor. A sub-constructor is registered and made available', 1559, 4, 1559, 79),
woosh.Token(woosh.COMMENT, '# by adding it to the mapping in OPEN_METH.', 1560, 4, 1560, 47),
woosh.Token(woosh.DEDENT, ' ', 1562, 0, 1562, 4),
woosh.Token(woosh.DEDENT, '', 1562, 4, 1562, 4),
woosh.Token(woosh.OP, '@', 1562, 4, 1562, 5),
woosh.Token(woosh.NAME, 'classmethod', 1562, 5, 1562, 16),
woosh.Token(woosh.NEWLINE, '\r\n', 1562, 16, 1563, 0),
woosh.Token(woosh.NAME, 'def', 1563, 4, 1563, 7),
woosh.Token(woosh.NAME, 'open', 1563, 8, 1563, 12),
woosh.Token(woosh.OP, '(', 1563, 12, 1563, 13),
woosh.Token(woosh.NAME, 'cls', 1563, 13, 1563, 16),
woosh.Token(woosh.OP, ',', 1563, 16, 1563, 17),
woosh.Token(woosh.NAME, 'name', 1563, 18, 1563, 22),
woosh.Token(woosh.OP, '=', 1563, 22, 1563, 23),
woosh.Token(woosh.NAME, 'None', 1563, 23, 1563, 27),
woosh.Token(woosh.OP, ',', 1563, 27, 1563, 28),
woosh.Token(woosh.NAME, 'mode', 1563, 29, 1563, 33),
woosh.Token(woosh.OP, '=', 1563, 33, 1563, 34),
woosh.Token(woosh.STRING, '"r"', 1563, 34, 1563, 37),
woosh.Token(woosh.OP, ',', 1563, 37, 1563, 38),
woosh.Token(woosh.NAME, 'fileobj', 1563, 39, 1563, 46),
woosh.Token(woosh.OP, '=', 1563, 46, 1563, 47),
woosh.Token(woosh.NAME, 'None', 1563, 47, 1563, 51),
woosh.Token(woosh.OP, ',', 1563, 51, 1563, 52),
woosh.Token(woosh.NAME, 'bufsize', 1563, 53, 1563, 60),
woosh.Token(woosh.OP, '=', 1563, 60, 1563, 61),
woosh.Token(woosh.NAME, 'RECORDSIZE', 1563, 61, 1563, 71),
woosh.Token(woosh.OP, ',', 1563, 71, 1563, 72),
woosh.Token(woosh.OP, '**', 1563, 73, 1563, 75),
woosh.Token(woosh.NAME, 'kwargs', 1563, 75, 1563, 81),
woosh.Token(woosh.OP, ')', 1563, 81, 1563, 82),
woosh.Token(woosh.OP, ':', 1563, 82, 1563, 83),
woosh.Token(woosh.NEWLINE, '\r\n', 1563, 83, 1564, 0),
woosh.Token(woosh.INDENT, ' ', 1564, 0, 1564, 8),
woosh.Token(woosh.STRING, '"""Open a tar archive for reading, writing or appending. Return\r\n an appropriate TarFile class.\r\n\r\n mode:\r\n \'r\' or \'r:*\' open for reading with transparent compression\r\n \'r:\' open for reading exclusively uncompressed\r\n \'r:gz\' open for reading with gzip compression\r\n \'r:bz2\' open for reading with bzip2 compression\r\n \'r:xz\' open for reading with lzma compression\r\n \'a\' or \'a:\' open for appending, creating the file if necessary\r\n \'w\' or \'w:\' open for writing without compression\r\n \'w:gz\' open for writing with gzip compression\r\n \'w:bz2\' open for writing with bzip2 compression\r\n \'w:xz\' open for writing with lzma compression\r\n\r\n \'x\' or \'x:\' create a tarfile exclusively without compression, raise\r\n an exception if the file is already created\r\n \'x:gz\' create a gzip compressed tarfile, raise an exception\r\n if the file is already created\r\n \'x:bz2\' create a bzip2 compressed tarfile, raise an exception\r\n if the file is already created\r\n \'x:xz\' create an lzma compressed tarfile, raise an exception\r\n if the file is already created\r\n\r\n \'r|*\' open a stream of tar blocks with transparent compression\r\n \'r|\' open an uncompressed stream of tar blocks for reading\r\n \'r|gz\' open a gzip compressed stream of tar blocks\r\n \'r|bz2\' open a bzip2 compressed stream of tar blocks\r\n \'r|xz\' open an lzma compressed stream of tar blocks\r\n \'w|\' open an uncompressed stream for writing\r\n \'w|gz\' open a gzip compressed stream for writing\r\n \'w|bz2\' open a bzip2 compressed stream for writing\r\n \'w|xz\' open an lzma compressed stream for writing\r\n """', 1564, 8, 1597, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 1597, 11, 1598, 0),
woosh.Token(woosh.NAME, 'if', 1599, 8, 1599, 10),
woosh.Token(woosh.NAME, 'not', 1599, 11, 1599, 14),
woosh.Token(woosh.NAME, 'name', 1599, 15, 1599, 19),
woosh.Token(woosh.NAME, 'and', 1599, 20, 1599, 23),
woosh.Token(woosh.NAME, 'not', 1599, 24, 1599, 27),
woosh.Token(woosh.NAME, 'fileobj', 1599, 28, 1599, 35),
woosh.Token(woosh.OP, ':', 1599, 35, 1599, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 1599, 36, 1600, 0),
woosh.Token(woosh.INDENT, ' ', 1600, 0, 1600, 12),
woosh.Token(woosh.NAME, 'raise', 1600, 12, 1600, 17),
woosh.Token(woosh.NAME, 'ValueError', 1600, 18, 1600, 28),
woosh.Token(woosh.OP, '(', 1600, 28, 1600, 29),
woosh.Token(woosh.STRING, '"nothing to open"', 1600, 29, 1600, 46),
woosh.Token(woosh.OP, ')', 1600, 46, 1600, 47),
woosh.Token(woosh.NEWLINE, '\r\n', 1600, 47, 1601, 0),
woosh.Token(woosh.DEDENT, ' ', 1602, 0, 1602, 8),
woosh.Token(woosh.NAME, 'if', 1602, 8, 1602, 10),
woosh.Token(woosh.NAME, 'mode', 1602, 11, 1602, 15),
woosh.Token(woosh.NAME, 'in', 1602, 16, 1602, 18),
woosh.Token(woosh.OP, '(', 1602, 19, 1602, 20),
woosh.Token(woosh.STRING, '"r"', 1602, 20, 1602, 23),
woosh.Token(woosh.OP, ',', 1602, 23, 1602, 24),
woosh.Token(woosh.STRING, '"r:*"', 1602, 25, 1602, 30),
woosh.Token(woosh.OP, ')', 1602, 30, 1602, 31),
woosh.Token(woosh.OP, ':', 1602, 31, 1602, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 1602, 32, 1603, 0),
woosh.Token(woosh.COMMENT, '# Find out which *open() is appropriate for opening the file.', 1603, 12, 1603, 73),
woosh.Token(woosh.INDENT, ' ', 1604, 0, 1604, 12),
woosh.Token(woosh.NAME, 'def', 1604, 12, 1604, 15),
woosh.Token(woosh.NAME, 'not_compressed', 1604, 16, 1604, 30),
woosh.Token(woosh.OP, '(', 1604, 30, 1604, 31),
woosh.Token(woosh.NAME, 'comptype', 1604, 31, 1604, 39),
woosh.Token(woosh.OP, ')', 1604, 39, 1604, 40),
woosh.Token(woosh.OP, ':', 1604, 40, 1604, 41),
woosh.Token(woosh.NEWLINE, '\r\n', 1604, 41, 1605, 0),
woosh.Token(woosh.INDENT, ' ', 1605, 0, 1605, 16),
woosh.Token(woosh.NAME, 'return', 1605, 16, 1605, 22),
woosh.Token(woosh.NAME, 'cls', 1605, 23, 1605, 26),
woosh.Token(woosh.OP, '.', 1605, 26, 1605, 27),
woosh.Token(woosh.NAME, 'OPEN_METH', 1605, 27, 1605, 36),
woosh.Token(woosh.OP, '[', 1605, 36, 1605, 37),
woosh.Token(woosh.NAME, 'comptype', 1605, 37, 1605, 45),
woosh.Token(woosh.OP, ']', 1605, 45, 1605, 46),
woosh.Token(woosh.OP, '==', 1605, 47, 1605, 49),
woosh.Token(woosh.STRING, "'taropen'", 1605, 50, 1605, 59),
woosh.Token(woosh.NEWLINE, '\r\n', 1605, 59, 1606, 0),
woosh.Token(woosh.DEDENT, ' ', 1606, 0, 1606, 12),
woosh.Token(woosh.NAME, 'for', 1606, 12, 1606, 15),
woosh.Token(woosh.NAME, 'comptype', 1606, 16, 1606, 24),
woosh.Token(woosh.NAME, 'in', 1606, 25, 1606, 27),
woosh.Token(woosh.NAME, 'sorted', 1606, 28, 1606, 34),
woosh.Token(woosh.OP, '(', 1606, 34, 1606, 35),
woosh.Token(woosh.NAME, 'cls', 1606, 35, 1606, 38),
woosh.Token(woosh.OP, '.', 1606, 38, 1606, 39),
woosh.Token(woosh.NAME, 'OPEN_METH', 1606, 39, 1606, 48),
woosh.Token(woosh.OP, ',', 1606, 48, 1606, 49),
woosh.Token(woosh.NAME, 'key', 1606, 50, 1606, 53),
woosh.Token(woosh.OP, '=', 1606, 53, 1606, 54),
woosh.Token(woosh.NAME, 'not_compressed', 1606, 54, 1606, 68),
woosh.Token(woosh.OP, ')', 1606, 68, 1606, 69),
woosh.Token(woosh.OP, ':', 1606, 69, 1606, 70),
woosh.Token(woosh.NEWLINE, '\r\n', 1606, 70, 1607, 0),
woosh.Token(woosh.INDENT, ' ', 1607, 0, 1607, 16),
woosh.Token(woosh.NAME, 'func', 1607, 16, 1607, 20),
woosh.Token(woosh.OP, '=', 1607, 21, 1607, 22),
woosh.Token(woosh.NAME, 'getattr', 1607, 23, 1607, 30),
woosh.Token(woosh.OP, '(', 1607, 30, 1607, 31),
woosh.Token(woosh.NAME, 'cls', 1607, 31, 1607, 34),
woosh.Token(woosh.OP, ',', 1607, 34, 1607, 35),
woosh.Token(woosh.NAME, 'cls', 1607, 36, 1607, 39),
woosh.Token(woosh.OP, '.', 1607, 39, 1607, 40),
woosh.Token(woosh.NAME, 'OPEN_METH', 1607, 40, 1607, 49),
woosh.Token(woosh.OP, '[', 1607, 49, 1607, 50),
woosh.Token(woosh.NAME, 'comptype', 1607, 50, 1607, 58),
woosh.Token(woosh.OP, ']', 1607, 58, 1607, 59),
woosh.Token(woosh.OP, ')', 1607, 59, 1607, 60),
woosh.Token(woosh.NEWLINE, '\r\n', 1607, 60, 1608, 0),
woosh.Token(woosh.NAME, 'if', 1608, 16, 1608, 18),
woosh.Token(woosh.NAME, 'fileobj', 1608, 19, 1608, 26),
woosh.Token(woosh.NAME, 'is', 1608, 27, 1608, 29),
woosh.Token(woosh.NAME, 'not', 1608, 30, 1608, 33),
woosh.Token(woosh.NAME, 'None', 1608, 34, 1608, 38),
woosh.Token(woosh.OP, ':', 1608, 38, 1608, 39),
woosh.Token(woosh.NEWLINE, '\r\n', 1608, 39, 1609, 0),
woosh.Token(woosh.INDENT, ' ', 1609, 0, 1609, 20),
woosh.Token(woosh.NAME, 'saved_pos', 1609, 20, 1609, 29),
woosh.Token(woosh.OP, '=', 1609, 30, 1609, 31),
woosh.Token(woosh.NAME, 'fileobj', 1609, 32, 1609, 39),
woosh.Token(woosh.OP, '.', 1609, 39, 1609, 40),
woosh.Token(woosh.NAME, 'tell', 1609, 40, 1609, 44),
woosh.Token(woosh.OP, '(', 1609, 44, 1609, 45),
woosh.Token(woosh.OP, ')', 1609, 45, 1609, 46),
woosh.Token(woosh.NEWLINE, '\r\n', 1609, 46, 1610, 0),
woosh.Token(woosh.DEDENT, ' ', 1610, 0, 1610, 16),
woosh.Token(woosh.NAME, 'try', 1610, 16, 1610, 19),
woosh.Token(woosh.OP, ':', 1610, 19, 1610, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 1610, 20, 1611, 0),
woosh.Token(woosh.INDENT, ' ', 1611, 0, 1611, 20),
woosh.Token(woosh.NAME, 'return', 1611, 20, 1611, 26),
woosh.Token(woosh.NAME, 'func', 1611, 27, 1611, 31),
woosh.Token(woosh.OP, '(', 1611, 31, 1611, 32),
woosh.Token(woosh.NAME, 'name', 1611, 32, 1611, 36),
woosh.Token(woosh.OP, ',', 1611, 36, 1611, 37),
woosh.Token(woosh.STRING, '"r"', 1611, 38, 1611, 41),
woosh.Token(woosh.OP, ',', 1611, 41, 1611, 42),
woosh.Token(woosh.NAME, 'fileobj', 1611, 43, 1611, 50),
woosh.Token(woosh.OP, ',', 1611, 50, 1611, 51),
woosh.Token(woosh.OP, '**', 1611, 52, 1611, 54),
woosh.Token(woosh.NAME, 'kwargs', 1611, 54, 1611, 60),
woosh.Token(woosh.OP, ')', 1611, 60, 1611, 61),
woosh.Token(woosh.NEWLINE, '\r\n', 1611, 61, 1612, 0),
woosh.Token(woosh.DEDENT, ' ', 1612, 0, 1612, 16),
woosh.Token(woosh.NAME, 'except', 1612, 16, 1612, 22),
woosh.Token(woosh.OP, '(', 1612, 23, 1612, 24),
woosh.Token(woosh.NAME, 'ReadError', 1612, 24, 1612, 33),
woosh.Token(woosh.OP, ',', 1612, 33, 1612, 34),
woosh.Token(woosh.NAME, 'CompressionError', 1612, 35, 1612, 51),
woosh.Token(woosh.OP, ')', 1612, 51, 1612, 52),
woosh.Token(woosh.OP, ':', 1612, 52, 1612, 53),
woosh.Token(woosh.NEWLINE, '\r\n', 1612, 53, 1613, 0),
woosh.Token(woosh.INDENT, ' ', 1613, 0, 1613, 20),
woosh.Token(woosh.NAME, 'if', 1613, 20, 1613, 22),
woosh.Token(woosh.NAME, 'fileobj', 1613, 23, 1613, 30),
woosh.Token(woosh.NAME, 'is', 1613, 31, 1613, 33),
woosh.Token(woosh.NAME, 'not', 1613, 34, 1613, 37),
woosh.Token(woosh.NAME, 'None', 1613, 38, 1613, 42),
woosh.Token(woosh.OP, ':', 1613, 42, 1613, 43),
woosh.Token(woosh.NEWLINE, '\r\n', 1613, 43, 1614, 0),
woosh.Token(woosh.INDENT, ' ', 1614, 0, 1614, 24),
woosh.Token(woosh.NAME, 'fileobj', 1614, 24, 1614, 31),
woosh.Token(woosh.OP, '.', 1614, 31, 1614, 32),
woosh.Token(woosh.NAME, 'seek', 1614, 32, 1614, 36),
woosh.Token(woosh.OP, '(', 1614, 36, 1614, 37),
woosh.Token(woosh.NAME, 'saved_pos', 1614, 37, 1614, 46),
woosh.Token(woosh.OP, ')', 1614, 46, 1614, 47),
woosh.Token(woosh.NEWLINE, '\r\n', 1614, 47, 1615, 0),
woosh.Token(woosh.DEDENT, ' ', 1615, 0, 1615, 20),
woosh.Token(woosh.NAME, 'continue', 1615, 20, 1615, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 1615, 28, 1616, 0),
woosh.Token(woosh.DEDENT, ' ', 1616, 0, 1616, 12),
woosh.Token(woosh.DEDENT, '', 1616, 12, 1616, 12),
woosh.Token(woosh.NAME, 'raise', 1616, 12, 1616, 17),
woosh.Token(woosh.NAME, 'ReadError', 1616, 18, 1616, 27),
woosh.Token(woosh.OP, '(', 1616, 27, 1616, 28),
woosh.Token(woosh.STRING, '"file could not be opened successfully"', 1616, 28, 1616, 67),
woosh.Token(woosh.OP, ')', 1616, 67, 1616, 68),
woosh.Token(woosh.NEWLINE, '\r\n', 1616, 68, 1617, 0),
woosh.Token(woosh.DEDENT, ' ', 1618, 0, 1618, 8),
woosh.Token(woosh.NAME, 'elif', 1618, 8, 1618, 12),
woosh.Token(woosh.STRING, '":"', 1618, 13, 1618, 16),
woosh.Token(woosh.NAME, 'in', 1618, 17, 1618, 19),
woosh.Token(woosh.NAME, 'mode', 1618, 20, 1618, 24),
woosh.Token(woosh.OP, ':', 1618, 24, 1618, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 1618, 25, 1619, 0),
woosh.Token(woosh.INDENT, ' ', 1619, 0, 1619, 12),
woosh.Token(woosh.NAME, 'filemode', 1619, 12, 1619, 20),
woosh.Token(woosh.OP, ',', 1619, 20, 1619, 21),
woosh.Token(woosh.NAME, 'comptype', 1619, 22, 1619, 30),
woosh.Token(woosh.OP, '=', 1619, 31, 1619, 32),
woosh.Token(woosh.NAME, 'mode', 1619, 33, 1619, 37),
woosh.Token(woosh.OP, '.', 1619, 37, 1619, 38),
woosh.Token(woosh.NAME, 'split', 1619, 38, 1619, 43),
woosh.Token(woosh.OP, '(', 1619, 43, 1619, 44),
woosh.Token(woosh.STRING, '":"', 1619, 44, 1619, 47),
woosh.Token(woosh.OP, ',', 1619, 47, 1619, 48),
woosh.Token(woosh.NUMBER, '1', 1619, 49, 1619, 50),
woosh.Token(woosh.OP, ')', 1619, 50, 1619, 51),
woosh.Token(woosh.NEWLINE, '\r\n', 1619, 51, 1620, 0),
woosh.Token(woosh.NAME, 'filemode', 1620, 12, 1620, 20),
woosh.Token(woosh.OP, '=', 1620, 21, 1620, 22),
woosh.Token(woosh.NAME, 'filemode', 1620, 23, 1620, 31),
woosh.Token(woosh.NAME, 'or', 1620, 32, 1620, 34),
woosh.Token(woosh.STRING, '"r"', 1620, 35, 1620, 38),
woosh.Token(woosh.NEWLINE, '\r\n', 1620, 38, 1621, 0),
woosh.Token(woosh.NAME, 'comptype', 1621, 12, 1621, 20),
woosh.Token(woosh.OP, '=', 1621, 21, 1621, 22),
woosh.Token(woosh.NAME, 'comptype', 1621, 23, 1621, 31),
woosh.Token(woosh.NAME, 'or', 1621, 32, 1621, 34),
woosh.Token(woosh.STRING, '"tar"', 1621, 35, 1621, 40),
woosh.Token(woosh.NEWLINE, '\r\n', 1621, 40, 1622, 0),
woosh.Token(woosh.COMMENT, '# Select the *open() function according to', 1623, 12, 1623, 54),
woosh.Token(woosh.COMMENT, '# given compression.', 1624, 12, 1624, 32),
woosh.Token(woosh.NAME, 'if', 1625, 12, 1625, 14),
woosh.Token(woosh.NAME, 'comptype', 1625, 15, 1625, 23),
woosh.Token(woosh.NAME, 'in', 1625, 24, 1625, 26),
woosh.Token(woosh.NAME, 'cls', 1625, 27, 1625, 30),
woosh.Token(woosh.OP, '.', 1625, 30, 1625, 31),
woosh.Token(woosh.NAME, 'OPEN_METH', 1625, 31, 1625, 40),
woosh.Token(woosh.OP, ':', 1625, 40, 1625, 41),
woosh.Token(woosh.NEWLINE, '\r\n', 1625, 41, 1626, 0),
woosh.Token(woosh.INDENT, ' ', 1626, 0, 1626, 16),
woosh.Token(woosh.NAME, 'func', 1626, 16, 1626, 20),
woosh.Token(woosh.OP, '=', 1626, 21, 1626, 22),
woosh.Token(woosh.NAME, 'getattr', 1626, 23, 1626, 30),
woosh.Token(woosh.OP, '(', 1626, 30, 1626, 31),
woosh.Token(woosh.NAME, 'cls', 1626, 31, 1626, 34),
woosh.Token(woosh.OP, ',', 1626, 34, 1626, 35),
woosh.Token(woosh.NAME, 'cls', 1626, 36, 1626, 39),
woosh.Token(woosh.OP, '.', 1626, 39, 1626, 40),
woosh.Token(woosh.NAME, 'OPEN_METH', 1626, 40, 1626, 49),
woosh.Token(woosh.OP, '[', 1626, 49, 1626, 50),
woosh.Token(woosh.NAME, 'comptype', 1626, 50, 1626, 58),
woosh.Token(woosh.OP, ']', 1626, 58, 1626, 59),
woosh.Token(woosh.OP, ')', 1626, 59, 1626, 60),
woosh.Token(woosh.NEWLINE, '\r\n', 1626, 60, 1627, 0),
woosh.Token(woosh.DEDENT, ' ', 1627, 0, 1627, 12),
woosh.Token(woosh.NAME, 'else', 1627, 12, 1627, 16),
woosh.Token(woosh.OP, ':', 1627, 16, 1627, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 1627, 17, 1628, 0),
woosh.Token(woosh.INDENT, ' ', 1628, 0, 1628, 16),
woosh.Token(woosh.NAME, 'raise', 1628, 16, 1628, 21),
woosh.Token(woosh.NAME, 'CompressionError', 1628, 22, 1628, 38),
woosh.Token(woosh.OP, '(', 1628, 38, 1628, 39),
woosh.Token(woosh.STRING, '"unknown compression type %r"', 1628, 39, 1628, 68),
woosh.Token(woosh.OP, '%', 1628, 69, 1628, 70),
woosh.Token(woosh.NAME, 'comptype', 1628, 71, 1628, 79),
woosh.Token(woosh.OP, ')', 1628, 79, 1628, 80),
woosh.Token(woosh.NEWLINE, '\r\n', 1628, 80, 1629, 0),
woosh.Token(woosh.DEDENT, ' ', 1629, 0, 1629, 12),
woosh.Token(woosh.NAME, 'return', 1629, 12, 1629, 18),
woosh.Token(woosh.NAME, 'func', 1629, 19, 1629, 23),
woosh.Token(woosh.OP, '(', 1629, 23, 1629, 24),
woosh.Token(woosh.NAME, 'name', 1629, 24, 1629, 28),
woosh.Token(woosh.OP, ',', 1629, 28, 1629, 29),
woosh.Token(woosh.NAME, 'filemode', 1629, 30, 1629, 38),
woosh.Token(woosh.OP, ',', 1629, 38, 1629, 39),
woosh.Token(woosh.NAME, 'fileobj', 1629, 40, 1629, 47),
woosh.Token(woosh.OP, ',', 1629, 47, 1629, 48),
woosh.Token(woosh.OP, '**', 1629, 49, 1629, 51),
woosh.Token(woosh.NAME, 'kwargs', 1629, 51, 1629, 57),
woosh.Token(woosh.OP, ')', 1629, 57, 1629, 58),
woosh.Token(woosh.NEWLINE, '\r\n', 1629, 58, 1630, 0),
woosh.Token(woosh.DEDENT, ' ', 1631, 0, 1631, 8),
woosh.Token(woosh.NAME, 'elif', 1631, 8, 1631, 12),
woosh.Token(woosh.STRING, '"|"', 1631, 13, 1631, 16),
woosh.Token(woosh.NAME, 'in', 1631, 17, 1631, 19),
woosh.Token(woosh.NAME, 'mode', 1631, 20, 1631, 24),
woosh.Token(woosh.OP, ':', 1631, 24, 1631, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 1631, 25, 1632, 0),
woosh.Token(woosh.INDENT, ' ', 1632, 0, 1632, 12),
woosh.Token(woosh.NAME, 'filemode', 1632, 12, 1632, 20),
woosh.Token(woosh.OP, ',', 1632, 20, 1632, 21),
woosh.Token(woosh.NAME, 'comptype', 1632, 22, 1632, 30),
woosh.Token(woosh.OP, '=', 1632, 31, 1632, 32),
woosh.Token(woosh.NAME, 'mode', 1632, 33, 1632, 37),
woosh.Token(woosh.OP, '.', 1632, 37, 1632, 38),
woosh.Token(woosh.NAME, 'split', 1632, 38, 1632, 43),
woosh.Token(woosh.OP, '(', 1632, 43, 1632, 44),
woosh.Token(woosh.STRING, '"|"', 1632, 44, 1632, 47),
woosh.Token(woosh.OP, ',', 1632, 47, 1632, 48),
woosh.Token(woosh.NUMBER, '1', 1632, 49, 1632, 50),
woosh.Token(woosh.OP, ')', 1632, 50, 1632, 51),
woosh.Token(woosh.NEWLINE, '\r\n', 1632, 51, 1633, 0),
woosh.Token(woosh.NAME, 'filemode', 1633, 12, 1633, 20),
woosh.Token(woosh.OP, '=', 1633, 21, 1633, 22),
woosh.Token(woosh.NAME, 'filemode', 1633, 23, 1633, 31),
woosh.Token(woosh.NAME, 'or', 1633, 32, 1633, 34),
woosh.Token(woosh.STRING, '"r"', 1633, 35, 1633, 38),
woosh.Token(woosh.NEWLINE, '\r\n', 1633, 38, 1634, 0),
woosh.Token(woosh.NAME, 'comptype', 1634, 12, 1634, 20),
woosh.Token(woosh.OP, '=', 1634, 21, 1634, 22),
woosh.Token(woosh.NAME, 'comptype', 1634, 23, 1634, 31),
woosh.Token(woosh.NAME, 'or', 1634, 32, 1634, 34),
woosh.Token(woosh.STRING, '"tar"', 1634, 35, 1634, 40),
woosh.Token(woosh.NEWLINE, '\r\n', 1634, 40, 1635, 0),
woosh.Token(woosh.NAME, 'if', 1636, 12, 1636, 14),
woosh.Token(woosh.NAME, 'filemode', 1636, 15, 1636, 23),
woosh.Token(woosh.NAME, 'not', 1636, 24, 1636, 27),
woosh.Token(woosh.NAME, 'in', 1636, 28, 1636, 30),
woosh.Token(woosh.OP, '(', 1636, 31, 1636, 32),
woosh.Token(woosh.STRING, '"r"', 1636, 32, 1636, 35),
woosh.Token(woosh.OP, ',', 1636, 35, 1636, 36),
woosh.Token(woosh.STRING, '"w"', 1636, 37, 1636, 40),
woosh.Token(woosh.OP, ')', 1636, 40, 1636, 41),
woosh.Token(woosh.OP, ':', 1636, 41, 1636, 42),
woosh.Token(woosh.NEWLINE, '\r\n', 1636, 42, 1637, 0),
woosh.Token(woosh.INDENT, ' ', 1637, 0, 1637, 16),
woosh.Token(woosh.NAME, 'raise', 1637, 16, 1637, 21),
woosh.Token(woosh.NAME, 'ValueError', 1637, 22, 1637, 32),
woosh.Token(woosh.OP, '(', 1637, 32, 1637, 33),
woosh.Token(woosh.STRING, '"mode must be \'r\' or \'w\'"', 1637, 33, 1637, 58),
woosh.Token(woosh.OP, ')', 1637, 58, 1637, 59),
woosh.Token(woosh.NEWLINE, '\r\n', 1637, 59, 1638, 0),
woosh.Token(woosh.DEDENT, ' ', 1639, 0, 1639, 12),
woosh.Token(woosh.NAME, 'stream', 1639, 12, 1639, 18),
woosh.Token(woosh.OP, '=', 1639, 19, 1639, 20),
woosh.Token(woosh.NAME, '_Stream', 1639, 21, 1639, 28),
woosh.Token(woosh.OP, '(', 1639, 28, 1639, 29),
woosh.Token(woosh.NAME, 'name', 1639, 29, 1639, 33),
woosh.Token(woosh.OP, ',', 1639, 33, 1639, 34),
woosh.Token(woosh.NAME, 'filemode', 1639, 35, 1639, 43),
woosh.Token(woosh.OP, ',', 1639, 43, 1639, 44),
woosh.Token(woosh.NAME, 'comptype', 1639, 45, 1639, 53),
woosh.Token(woosh.OP, ',', 1639, 53, 1639, 54),
woosh.Token(woosh.NAME, 'fileobj', 1639, 55, 1639, 62),
woosh.Token(woosh.OP, ',', 1639, 62, 1639, 63),
woosh.Token(woosh.NAME, 'bufsize', 1639, 64, 1639, 71),
woosh.Token(woosh.OP, ')', 1639, 71, 1639, 72),
woosh.Token(woosh.NEWLINE, '\r\n', 1639, 72, 1640, 0),
woosh.Token(woosh.NAME, 'try', 1640, 12, 1640, 15),
woosh.Token(woosh.OP, ':', 1640, 15, 1640, 16),
woosh.Token(woosh.NEWLINE, '\r\n', 1640, 16, 1641, 0),
woosh.Token(woosh.INDENT, ' ', 1641, 0, 1641, 16),
woosh.Token(woosh.NAME, 't', 1641, 16, 1641, 17),
woosh.Token(woosh.OP, '=', 1641, 18, 1641, 19),
woosh.Token(woosh.NAME, 'cls', 1641, 20, 1641, 23),
woosh.Token(woosh.OP, '(', 1641, 23, 1641, 24),
woosh.Token(woosh.NAME, 'name', 1641, 24, 1641, 28),
woosh.Token(woosh.OP, ',', 1641, 28, 1641, 29),
woosh.Token(woosh.NAME, 'filemode', 1641, 30, 1641, 38),
woosh.Token(woosh.OP, ',', 1641, 38, 1641, 39),
woosh.Token(woosh.NAME, 'stream', 1641, 40, 1641, 46),
woosh.Token(woosh.OP, ',', 1641, 46, 1641, 47),
woosh.Token(woosh.OP, '**', 1641, 48, 1641, 50),
woosh.Token(woosh.NAME, 'kwargs', 1641, 50, 1641, 56),
woosh.Token(woosh.OP, ')', 1641, 56, 1641, 57),
woosh.Token(woosh.NEWLINE, '\r\n', 1641, 57, 1642, 0),
woosh.Token(woosh.DEDENT, ' ', 1642, 0, 1642, 12),
woosh.Token(woosh.NAME, 'except', 1642, 12, 1642, 18),
woosh.Token(woosh.OP, ':', 1642, 18, 1642, 19),
woosh.Token(woosh.NEWLINE, '\r\n', 1642, 19, 1643, 0),
woosh.Token(woosh.INDENT, ' ', 1643, 0, 1643, 16),
woosh.Token(woosh.NAME, 'stream', 1643, 16, 1643, 22),
woosh.Token(woosh.OP, '.', 1643, 22, 1643, 23),
woosh.Token(woosh.NAME, 'close', 1643, 23, 1643, 28),
woosh.Token(woosh.OP, '(', 1643, 28, 1643, 29),
woosh.Token(woosh.OP, ')', 1643, 29, 1643, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 1643, 30, 1644, 0),
woosh.Token(woosh.NAME, 'raise', 1644, 16, 1644, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 1644, 21, 1645, 0),
woosh.Token(woosh.DEDENT, ' ', 1645, 0, 1645, 12),
woosh.Token(woosh.NAME, 't', 1645, 12, 1645, 13),
woosh.Token(woosh.OP, '.', 1645, 13, 1645, 14),
woosh.Token(woosh.NAME, '_extfileobj', 1645, 14, 1645, 25),
woosh.Token(woosh.OP, '=', 1645, 26, 1645, 27),
woosh.Token(woosh.NAME, 'False', 1645, 28, 1645, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 1645, 33, 1646, 0),
woosh.Token(woosh.NAME, 'return', 1646, 12, 1646, 18),
woosh.Token(woosh.NAME, 't', 1646, 19, 1646, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 1646, 20, 1647, 0),
woosh.Token(woosh.DEDENT, ' ', 1648, 0, 1648, 8),
woosh.Token(woosh.NAME, 'elif', 1648, 8, 1648, 12),
woosh.Token(woosh.NAME, 'mode', 1648, 13, 1648, 17),
woosh.Token(woosh.NAME, 'in', 1648, 18, 1648, 20),
woosh.Token(woosh.OP, '(', 1648, 21, 1648, 22),
woosh.Token(woosh.STRING, '"a"', 1648, 22, 1648, 25),
woosh.Token(woosh.OP, ',', 1648, 25, 1648, 26),
woosh.Token(woosh.STRING, '"w"', 1648, 27, 1648, 30),
woosh.Token(woosh.OP, ',', 1648, 30, 1648, 31),
woosh.Token(woosh.STRING, '"x"', 1648, 32, 1648, 35),
woosh.Token(woosh.OP, ')', 1648, 35, 1648, 36),
woosh.Token(woosh.OP, ':', 1648, 36, 1648, 37),
woosh.Token(woosh.NEWLINE, '\r\n', 1648, 37, 1649, 0),
woosh.Token(woosh.INDENT, ' ', 1649, 0, 1649, 12),
woosh.Token(woosh.NAME, 'return', 1649, 12, 1649, 18),
woosh.Token(woosh.NAME, 'cls', 1649, 19, 1649, 22),
woosh.Token(woosh.OP, '.', 1649, 22, 1649, 23),
woosh.Token(woosh.NAME, 'taropen', 1649, 23, 1649, 30),
woosh.Token(woosh.OP, '(', 1649, 30, 1649, 31),
woosh.Token(woosh.NAME, 'name', 1649, 31, 1649, 35),
woosh.Token(woosh.OP, ',', 1649, 35, 1649, 36),
woosh.Token(woosh.NAME, 'mode', 1649, 37, 1649, 41),
woosh.Token(woosh.OP, ',', 1649, 41, 1649, 42),
woosh.Token(woosh.NAME, 'fileobj', 1649, 43, 1649, 50),
woosh.Token(woosh.OP, ',', 1649, 50, 1649, 51),
woosh.Token(woosh.OP, '**', 1649, 52, 1649, 54),
woosh.Token(woosh.NAME, 'kwargs', 1649, 54, 1649, 60),
woosh.Token(woosh.OP, ')', 1649, 60, 1649, 61),
woosh.Token(woosh.NEWLINE, '\r\n', 1649, 61, 1650, 0),
woosh.Token(woosh.DEDENT, ' ', 1651, 0, 1651, 8),
woosh.Token(woosh.NAME, 'raise', 1651, 8, 1651, 13),
woosh.Token(woosh.NAME, 'ValueError', 1651, 14, 1651, 24),
woosh.Token(woosh.OP, '(', 1651, 24, 1651, 25),
woosh.Token(woosh.STRING, '"undiscernible mode"', 1651, 25, 1651, 45),
woosh.Token(woosh.OP, ')', 1651, 45, 1651, 46),
woosh.Token(woosh.NEWLINE, '\r\n', 1651, 46, 1652, 0),
woosh.Token(woosh.DEDENT, ' ', 1653, 0, 1653, 4),
woosh.Token(woosh.OP, '@', 1653, 4, 1653, 5),
woosh.Token(woosh.NAME, 'classmethod', 1653, 5, 1653, 16),
woosh.Token(woosh.NEWLINE, '\r\n', 1653, 16, 1654, 0),
woosh.Token(woosh.NAME, 'def', 1654, 4, 1654, 7),
woosh.Token(woosh.NAME, 'taropen', 1654, 8, 1654, 15),
woosh.Token(woosh.OP, '(', 1654, 15, 1654, 16),
woosh.Token(woosh.NAME, 'cls', 1654, 16, 1654, 19),
woosh.Token(woosh.OP, ',', 1654, 19, 1654, 20),
woosh.Token(woosh.NAME, 'name', 1654, 21, 1654, 25),
woosh.Token(woosh.OP, ',', 1654, 25, 1654, 26),
woosh.Token(woosh.NAME, 'mode', 1654, 27, 1654, 31),
woosh.Token(woosh.OP, '=', 1654, 31, 1654, 32),
woosh.Token(woosh.STRING, '"r"', 1654, 32, 1654, 35),
woosh.Token(woosh.OP, ',', 1654, 35, 1654, 36),
woosh.Token(woosh.NAME, 'fileobj', 1654, 37, 1654, 44),
woosh.Token(woosh.OP, '=', 1654, 44, 1654, 45),
woosh.Token(woosh.NAME, 'None', 1654, 45, 1654, 49),
woosh.Token(woosh.OP, ',', 1654, 49, 1654, 50),
woosh.Token(woosh.OP, '**', 1654, 51, 1654, 53),
woosh.Token(woosh.NAME, 'kwargs', 1654, 53, 1654, 59),
woosh.Token(woosh.OP, ')', 1654, 59, 1654, 60),
woosh.Token(woosh.OP, ':', 1654, 60, 1654, 61),
woosh.Token(woosh.NEWLINE, '\r\n', 1654, 61, 1655, 0),
woosh.Token(woosh.INDENT, ' ', 1655, 0, 1655, 8),
woosh.Token(woosh.STRING, '"""Open uncompressed tar archive name for reading or writing.\r\n """', 1655, 8, 1656, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 1656, 11, 1657, 0),
woosh.Token(woosh.NAME, 'if', 1657, 8, 1657, 10),
woosh.Token(woosh.NAME, 'mode', 1657, 11, 1657, 15),
woosh.Token(woosh.NAME, 'not', 1657, 16, 1657, 19),
woosh.Token(woosh.NAME, 'in', 1657, 20, 1657, 22),
woosh.Token(woosh.OP, '(', 1657, 23, 1657, 24),
woosh.Token(woosh.STRING, '"r"', 1657, 24, 1657, 27),
woosh.Token(woosh.OP, ',', 1657, 27, 1657, 28),
woosh.Token(woosh.STRING, '"a"', 1657, 29, 1657, 32),
woosh.Token(woosh.OP, ',', 1657, 32, 1657, 33),
woosh.Token(woosh.STRING, '"w"', 1657, 34, 1657, 37),
woosh.Token(woosh.OP, ',', 1657, 37, 1657, 38),
woosh.Token(woosh.STRING, '"x"', 1657, 39, 1657, 42),
woosh.Token(woosh.OP, ')', 1657, 42, 1657, 43),
woosh.Token(woosh.OP, ':', 1657, 43, 1657, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 1657, 44, 1658, 0),
woosh.Token(woosh.INDENT, ' ', 1658, 0, 1658, 12),
woosh.Token(woosh.NAME, 'raise', 1658, 12, 1658, 17),
woosh.Token(woosh.NAME, 'ValueError', 1658, 18, 1658, 28),
woosh.Token(woosh.OP, '(', 1658, 28, 1658, 29),
woosh.Token(woosh.STRING, '"mode must be \'r\', \'a\', \'w\' or \'x\'"', 1658, 29, 1658, 64),
woosh.Token(woosh.OP, ')', 1658, 64, 1658, 65),
woosh.Token(woosh.NEWLINE, '\r\n', 1658, 65, 1659, 0),
woosh.Token(woosh.DEDENT, ' ', 1659, 0, 1659, 8),
woosh.Token(woosh.NAME, 'return', 1659, 8, 1659, 14),
woosh.Token(woosh.NAME, 'cls', 1659, 15, 1659, 18),
woosh.Token(woosh.OP, '(', 1659, 18, 1659, 19),
woosh.Token(woosh.NAME, 'name', 1659, 19, 1659, 23),
woosh.Token(woosh.OP, ',', 1659, 23, 1659, 24),
woosh.Token(woosh.NAME, 'mode', 1659, 25, 1659, 29),
woosh.Token(woosh.OP, ',', 1659, 29, 1659, 30),
woosh.Token(woosh.NAME, 'fileobj', 1659, 31, 1659, 38),
woosh.Token(woosh.OP, ',', 1659, 38, 1659, 39),
woosh.Token(woosh.OP, '**', 1659, 40, 1659, 42),
woosh.Token(woosh.NAME, 'kwargs', 1659, 42, 1659, 48),
woosh.Token(woosh.OP, ')', 1659, 48, 1659, 49),
woosh.Token(woosh.NEWLINE, '\r\n', 1659, 49, 1660, 0),
woosh.Token(woosh.DEDENT, ' ', 1661, 0, 1661, 4),
woosh.Token(woosh.OP, '@', 1661, 4, 1661, 5),
woosh.Token(woosh.NAME, 'classmethod', 1661, 5, 1661, 16),
woosh.Token(woosh.NEWLINE, '\r\n', 1661, 16, 1662, 0),
woosh.Token(woosh.NAME, 'def', 1662, 4, 1662, 7),
woosh.Token(woosh.NAME, 'gzopen', 1662, 8, 1662, 14),
woosh.Token(woosh.OP, '(', 1662, 14, 1662, 15),
woosh.Token(woosh.NAME, 'cls', 1662, 15, 1662, 18),
woosh.Token(woosh.OP, ',', 1662, 18, 1662, 19),
woosh.Token(woosh.NAME, 'name', 1662, 20, 1662, 24),
woosh.Token(woosh.OP, ',', 1662, 24, 1662, 25),
woosh.Token(woosh.NAME, 'mode', 1662, 26, 1662, 30),
woosh.Token(woosh.OP, '=', 1662, 30, 1662, 31),
woosh.Token(woosh.STRING, '"r"', 1662, 31, 1662, 34),
woosh.Token(woosh.OP, ',', 1662, 34, 1662, 35),
woosh.Token(woosh.NAME, 'fileobj', 1662, 36, 1662, 43),
woosh.Token(woosh.OP, '=', 1662, 43, 1662, 44),
woosh.Token(woosh.NAME, 'None', 1662, 44, 1662, 48),
woosh.Token(woosh.OP, ',', 1662, 48, 1662, 49),
woosh.Token(woosh.NAME, 'compresslevel', 1662, 50, 1662, 63),
woosh.Token(woosh.OP, '=', 1662, 63, 1662, 64),
woosh.Token(woosh.NUMBER, '9', 1662, 64, 1662, 65),
woosh.Token(woosh.OP, ',', 1662, 65, 1662, 66),
woosh.Token(woosh.OP, '**', 1662, 67, 1662, 69),
woosh.Token(woosh.NAME, 'kwargs', 1662, 69, 1662, 75),
woosh.Token(woosh.OP, ')', 1662, 75, 1662, 76),
woosh.Token(woosh.OP, ':', 1662, 76, 1662, 77),
woosh.Token(woosh.NEWLINE, '\r\n', 1662, 77, 1663, 0),
woosh.Token(woosh.INDENT, ' ', 1663, 0, 1663, 8),
woosh.Token(woosh.STRING, '"""Open gzip compressed tar archive name for reading or writing.\r\n Appending is not allowed.\r\n """', 1663, 8, 1665, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 1665, 11, 1666, 0),
woosh.Token(woosh.NAME, 'if', 1666, 8, 1666, 10),
woosh.Token(woosh.NAME, 'mode', 1666, 11, 1666, 15),
woosh.Token(woosh.NAME, 'not', 1666, 16, 1666, 19),
woosh.Token(woosh.NAME, 'in', 1666, 20, 1666, 22),
woosh.Token(woosh.OP, '(', 1666, 23, 1666, 24),
woosh.Token(woosh.STRING, '"r"', 1666, 24, 1666, 27),
woosh.Token(woosh.OP, ',', 1666, 27, 1666, 28),
woosh.Token(woosh.STRING, '"w"', 1666, 29, 1666, 32),
woosh.Token(woosh.OP, ',', 1666, 32, 1666, 33),
woosh.Token(woosh.STRING, '"x"', 1666, 34, 1666, 37),
woosh.Token(woosh.OP, ')', 1666, 37, 1666, 38),
woosh.Token(woosh.OP, ':', 1666, 38, 1666, 39),
woosh.Token(woosh.NEWLINE, '\r\n', 1666, 39, 1667, 0),
woosh.Token(woosh.INDENT, ' ', 1667, 0, 1667, 12),
woosh.Token(woosh.NAME, 'raise', 1667, 12, 1667, 17),
woosh.Token(woosh.NAME, 'ValueError', 1667, 18, 1667, 28),
woosh.Token(woosh.OP, '(', 1667, 28, 1667, 29),
woosh.Token(woosh.STRING, '"mode must be \'r\', \'w\' or \'x\'"', 1667, 29, 1667, 59),
woosh.Token(woosh.OP, ')', 1667, 59, 1667, 60),
woosh.Token(woosh.NEWLINE, '\r\n', 1667, 60, 1668, 0),
woosh.Token(woosh.DEDENT, ' ', 1669, 0, 1669, 8),
woosh.Token(woosh.NAME, 'try', 1669, 8, 1669, 11),
woosh.Token(woosh.OP, ':', 1669, 11, 1669, 12),
woosh.Token(woosh.NEWLINE, '\r\n', 1669, 12, 1670, 0),
woosh.Token(woosh.INDENT, ' ', 1670, 0, 1670, 12),
woosh.Token(woosh.NAME, 'from', 1670, 12, 1670, 16),
woosh.Token(woosh.NAME, 'gzip', 1670, 17, 1670, 21),
woosh.Token(woosh.NAME, 'import', 1670, 22, 1670, 28),
woosh.Token(woosh.NAME, 'GzipFile', 1670, 29, 1670, 37),
woosh.Token(woosh.NEWLINE, '\r\n', 1670, 37, 1671, 0),
woosh.Token(woosh.DEDENT, ' ', 1671, 0, 1671, 8),
woosh.Token(woosh.NAME, 'except', 1671, 8, 1671, 14),
woosh.Token(woosh.NAME, 'ImportError', 1671, 15, 1671, 26),
woosh.Token(woosh.OP, ':', 1671, 26, 1671, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 1671, 27, 1672, 0),
woosh.Token(woosh.INDENT, ' ', 1672, 0, 1672, 12),
woosh.Token(woosh.NAME, 'raise', 1672, 12, 1672, 17),
woosh.Token(woosh.NAME, 'CompressionError', 1672, 18, 1672, 34),
woosh.Token(woosh.OP, '(', 1672, 34, 1672, 35),
woosh.Token(woosh.STRING, '"gzip module is not available"', 1672, 35, 1672, 65),
woosh.Token(woosh.OP, ')', 1672, 65, 1672, 66),
woosh.Token(woosh.NEWLINE, '\r\n', 1672, 66, 1673, 0),
woosh.Token(woosh.DEDENT, ' ', 1674, 0, 1674, 8),
woosh.Token(woosh.NAME, 'try', 1674, 8, 1674, 11),
woosh.Token(woosh.OP, ':', 1674, 11, 1674, 12),
woosh.Token(woosh.NEWLINE, '\r\n', 1674, 12, 1675, 0),
woosh.Token(woosh.INDENT, ' ', 1675, 0, 1675, 12),
woosh.Token(woosh.NAME, 'fileobj', 1675, 12, 1675, 19),
woosh.Token(woosh.OP, '=', 1675, 20, 1675, 21),
woosh.Token(woosh.NAME, 'GzipFile', 1675, 22, 1675, 30),
woosh.Token(woosh.OP, '(', 1675, 30, 1675, 31),
woosh.Token(woosh.NAME, 'name', 1675, 31, 1675, 35),
woosh.Token(woosh.OP, ',', 1675, 35, 1675, 36),
woosh.Token(woosh.NAME, 'mode', 1675, 37, 1675, 41),
woosh.Token(woosh.OP, '+', 1675, 42, 1675, 43),
woosh.Token(woosh.STRING, '"b"', 1675, 44, 1675, 47),
woosh.Token(woosh.OP, ',', 1675, 47, 1675, 48),
woosh.Token(woosh.NAME, 'compresslevel', 1675, 49, 1675, 62),
woosh.Token(woosh.OP, ',', 1675, 62, 1675, 63),
woosh.Token(woosh.NAME, 'fileobj', 1675, 64, 1675, 71),
woosh.Token(woosh.OP, ')', 1675, 71, 1675, 72),
woosh.Token(woosh.NEWLINE, '\r\n', 1675, 72, 1676, 0),
woosh.Token(woosh.DEDENT, ' ', 1676, 0, 1676, 8),
woosh.Token(woosh.NAME, 'except', 1676, 8, 1676, 14),
woosh.Token(woosh.NAME, 'OSError', 1676, 15, 1676, 22),
woosh.Token(woosh.OP, ':', 1676, 22, 1676, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 1676, 23, 1677, 0),
woosh.Token(woosh.INDENT, ' ', 1677, 0, 1677, 12),
woosh.Token(woosh.NAME, 'if', 1677, 12, 1677, 14),
woosh.Token(woosh.NAME, 'fileobj', 1677, 15, 1677, 22),
woosh.Token(woosh.NAME, 'is', 1677, 23, 1677, 25),
woosh.Token(woosh.NAME, 'not', 1677, 26, 1677, 29),
woosh.Token(woosh.NAME, 'None', 1677, 30, 1677, 34),
woosh.Token(woosh.NAME, 'and', 1677, 35, 1677, 38),
woosh.Token(woosh.NAME, 'mode', 1677, 39, 1677, 43),
woosh.Token(woosh.OP, '==', 1677, 44, 1677, 46),
woosh.Token(woosh.STRING, "'r'", 1677, 47, 1677, 50),
woosh.Token(woosh.OP, ':', 1677, 50, 1677, 51),
woosh.Token(woosh.NEWLINE, '\r\n', 1677, 51, 1678, 0),
woosh.Token(woosh.INDENT, ' ', 1678, 0, 1678, 16),
woosh.Token(woosh.NAME, 'raise', 1678, 16, 1678, 21),
woosh.Token(woosh.NAME, 'ReadError', 1678, 22, 1678, 31),
woosh.Token(woosh.OP, '(', 1678, 31, 1678, 32),
woosh.Token(woosh.STRING, '"not a gzip file"', 1678, 32, 1678, 49),
woosh.Token(woosh.OP, ')', 1678, 49, 1678, 50),
woosh.Token(woosh.NEWLINE, '\r\n', 1678, 50, 1679, 0),
woosh.Token(woosh.DEDENT, ' ', 1679, 0, 1679, 12),
woosh.Token(woosh.NAME, 'raise', 1679, 12, 1679, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 1679, 17, 1680, 0),
woosh.Token(woosh.DEDENT, ' ', 1681, 0, 1681, 8),
woosh.Token(woosh.NAME, 'try', 1681, 8, 1681, 11),
woosh.Token(woosh.OP, ':', 1681, 11, 1681, 12),
woosh.Token(woosh.NEWLINE, '\r\n', 1681, 12, 1682, 0),
woosh.Token(woosh.INDENT, ' ', 1682, 0, 1682, 12),
woosh.Token(woosh.NAME, 't', 1682, 12, 1682, 13),
woosh.Token(woosh.OP, '=', 1682, 14, 1682, 15),
woosh.Token(woosh.NAME, 'cls', 1682, 16, 1682, 19),
woosh.Token(woosh.OP, '.', 1682, 19, 1682, 20),
woosh.Token(woosh.NAME, 'taropen', 1682, 20, 1682, 27),
woosh.Token(woosh.OP, '(', 1682, 27, 1682, 28),
woosh.Token(woosh.NAME, 'name', 1682, 28, 1682, 32),
woosh.Token(woosh.OP, ',', 1682, 32, 1682, 33),
woosh.Token(woosh.NAME, 'mode', 1682, 34, 1682, 38),
woosh.Token(woosh.OP, ',', 1682, 38, 1682, 39),
woosh.Token(woosh.NAME, 'fileobj', 1682, 40, 1682, 47),
woosh.Token(woosh.OP, ',', 1682, 47, 1682, 48),
woosh.Token(woosh.OP, '**', 1682, 49, 1682, 51),
woosh.Token(woosh.NAME, 'kwargs', 1682, 51, 1682, 57),
woosh.Token(woosh.OP, ')', 1682, 57, 1682, 58),
woosh.Token(woosh.NEWLINE, '\r\n', 1682, 58, 1683, 0),
woosh.Token(woosh.DEDENT, ' ', 1683, 0, 1683, 8),
woosh.Token(woosh.NAME, 'except', 1683, 8, 1683, 14),
woosh.Token(woosh.NAME, 'OSError', 1683, 15, 1683, 22),
woosh.Token(woosh.OP, ':', 1683, 22, 1683, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 1683, 23, 1684, 0),
woosh.Token(woosh.INDENT, ' ', 1684, 0, 1684, 12),
woosh.Token(woosh.NAME, 'fileobj', 1684, 12, 1684, 19),
woosh.Token(woosh.OP, '.', 1684, 19, 1684, 20),
woosh.Token(woosh.NAME, 'close', 1684, 20, 1684, 25),
woosh.Token(woosh.OP, '(', 1684, 25, 1684, 26),
woosh.Token(woosh.OP, ')', 1684, 26, 1684, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 1684, 27, 1685, 0),
woosh.Token(woosh.NAME, 'if', 1685, 12, 1685, 14),
woosh.Token(woosh.NAME, 'mode', 1685, 15, 1685, 19),
woosh.Token(woosh.OP, '==', 1685, 20, 1685, 22),
woosh.Token(woosh.STRING, "'r'", 1685, 23, 1685, 26),
woosh.Token(woosh.OP, ':', 1685, 26, 1685, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 1685, 27, 1686, 0),
woosh.Token(woosh.INDENT, ' ', 1686, 0, 1686, 16),
woosh.Token(woosh.NAME, 'raise', 1686, 16, 1686, 21),
woosh.Token(woosh.NAME, 'ReadError', 1686, 22, 1686, 31),
woosh.Token(woosh.OP, '(', 1686, 31, 1686, 32),
woosh.Token(woosh.STRING, '"not a gzip file"', 1686, 32, 1686, 49),
woosh.Token(woosh.OP, ')', 1686, 49, 1686, 50),
woosh.Token(woosh.NEWLINE, '\r\n', 1686, 50, 1687, 0),
woosh.Token(woosh.DEDENT, ' ', 1687, 0, 1687, 12),
woosh.Token(woosh.NAME, 'raise', 1687, 12, 1687, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 1687, 17, 1688, 0),
woosh.Token(woosh.DEDENT, ' ', 1688, 0, 1688, 8),
woosh.Token(woosh.NAME, 'except', 1688, 8, 1688, 14),
woosh.Token(woosh.OP, ':', 1688, 14, 1688, 15),
woosh.Token(woosh.NEWLINE, '\r\n', 1688, 15, 1689, 0),
woosh.Token(woosh.INDENT, ' ', 1689, 0, 1689, 12),
woosh.Token(woosh.NAME, 'fileobj', 1689, 12, 1689, 19),
woosh.Token(woosh.OP, '.', 1689, 19, 1689, 20),
woosh.Token(woosh.NAME, 'close', 1689, 20, 1689, 25),
woosh.Token(woosh.OP, '(', 1689, 25, 1689, 26),
woosh.Token(woosh.OP, ')', 1689, 26, 1689, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 1689, 27, 1690, 0),
woosh.Token(woosh.NAME, 'raise', 1690, 12, 1690, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 1690, 17, 1691, 0),
woosh.Token(woosh.DEDENT, ' ', 1691, 0, 1691, 8),
woosh.Token(woosh.NAME, 't', 1691, 8, 1691, 9),
woosh.Token(woosh.OP, '.', 1691, 9, 1691, 10),
woosh.Token(woosh.NAME, '_extfileobj', 1691, 10, 1691, 21),
woosh.Token(woosh.OP, '=', 1691, 22, 1691, 23),
woosh.Token(woosh.NAME, 'False', 1691, 24, 1691, 29),
woosh.Token(woosh.NEWLINE, '\r\n', 1691, 29, 1692, 0),
woosh.Token(woosh.NAME, 'return', 1692, 8, 1692, 14),
woosh.Token(woosh.NAME, 't', 1692, 15, 1692, 16),
woosh.Token(woosh.NEWLINE, '\r\n', 1692, 16, 1693, 0),
woosh.Token(woosh.DEDENT, ' ', 1694, 0, 1694, 4),
woosh.Token(woosh.OP, '@', 1694, 4, 1694, 5),
woosh.Token(woosh.NAME, 'classmethod', 1694, 5, 1694, 16),
woosh.Token(woosh.NEWLINE, '\r\n', 1694, 16, 1695, 0),
woosh.Token(woosh.NAME, 'def', 1695, 4, 1695, 7),
woosh.Token(woosh.NAME, 'bz2open', 1695, 8, 1695, 15),
woosh.Token(woosh.OP, '(', 1695, 15, 1695, 16),
woosh.Token(woosh.NAME, 'cls', 1695, 16, 1695, 19),
woosh.Token(woosh.OP, ',', 1695, 19, 1695, 20),
woosh.Token(woosh.NAME, 'name', 1695, 21, 1695, 25),
woosh.Token(woosh.OP, ',', 1695, 25, 1695, 26),
woosh.Token(woosh.NAME, 'mode', 1695, 27, 1695, 31),
woosh.Token(woosh.OP, '=', 1695, 31, 1695, 32),
woosh.Token(woosh.STRING, '"r"', 1695, 32, 1695, 35),
woosh.Token(woosh.OP, ',', 1695, 35, 1695, 36),
woosh.Token(woosh.NAME, 'fileobj', 1695, 37, 1695, 44),
woosh.Token(woosh.OP, '=', 1695, 44, 1695, 45),
woosh.Token(woosh.NAME, 'None', 1695, 45, 1695, 49),
woosh.Token(woosh.OP, ',', 1695, 49, 1695, 50),
woosh.Token(woosh.NAME, 'compresslevel', 1695, 51, 1695, 64),
woosh.Token(woosh.OP, '=', 1695, 64, 1695, 65),
woosh.Token(woosh.NUMBER, '9', 1695, 65, 1695, 66),
woosh.Token(woosh.OP, ',', 1695, 66, 1695, 67),
woosh.Token(woosh.OP, '**', 1695, 68, 1695, 70),
woosh.Token(woosh.NAME, 'kwargs', 1695, 70, 1695, 76),
woosh.Token(woosh.OP, ')', 1695, 76, 1695, 77),
woosh.Token(woosh.OP, ':', 1695, 77, 1695, 78),
woosh.Token(woosh.NEWLINE, '\r\n', 1695, 78, 1696, 0),
woosh.Token(woosh.INDENT, ' ', 1696, 0, 1696, 8),
woosh.Token(woosh.STRING, '"""Open bzip2 compressed tar archive name for reading or writing.\r\n Appending is not allowed.\r\n """', 1696, 8, 1698, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 1698, 11, 1699, 0),
woosh.Token(woosh.NAME, 'if', 1699, 8, 1699, 10),
woosh.Token(woosh.NAME, 'mode', 1699, 11, 1699, 15),
woosh.Token(woosh.NAME, 'not', 1699, 16, 1699, 19),
woosh.Token(woosh.NAME, 'in', 1699, 20, 1699, 22),
woosh.Token(woosh.OP, '(', 1699, 23, 1699, 24),
woosh.Token(woosh.STRING, '"r"', 1699, 24, 1699, 27),
woosh.Token(woosh.OP, ',', 1699, 27, 1699, 28),
woosh.Token(woosh.STRING, '"w"', 1699, 29, 1699, 32),
woosh.Token(woosh.OP, ',', 1699, 32, 1699, 33),
woosh.Token(woosh.STRING, '"x"', 1699, 34, 1699, 37),
woosh.Token(woosh.OP, ')', 1699, 37, 1699, 38),
woosh.Token(woosh.OP, ':', 1699, 38, 1699, 39),
woosh.Token(woosh.NEWLINE, '\r\n', 1699, 39, 1700, 0),
woosh.Token(woosh.INDENT, ' ', 1700, 0, 1700, 12),
woosh.Token(woosh.NAME, 'raise', 1700, 12, 1700, 17),
woosh.Token(woosh.NAME, 'ValueError', 1700, 18, 1700, 28),
woosh.Token(woosh.OP, '(', 1700, 28, 1700, 29),
woosh.Token(woosh.STRING, '"mode must be \'r\', \'w\' or \'x\'"', 1700, 29, 1700, 59),
woosh.Token(woosh.OP, ')', 1700, 59, 1700, 60),
woosh.Token(woosh.NEWLINE, '\r\n', 1700, 60, 1701, 0),
woosh.Token(woosh.DEDENT, ' ', 1702, 0, 1702, 8),
woosh.Token(woosh.NAME, 'try', 1702, 8, 1702, 11),
woosh.Token(woosh.OP, ':', 1702, 11, 1702, 12),
woosh.Token(woosh.NEWLINE, '\r\n', 1702, 12, 1703, 0),
woosh.Token(woosh.INDENT, ' ', 1703, 0, 1703, 12),
woosh.Token(woosh.NAME, 'from', 1703, 12, 1703, 16),
woosh.Token(woosh.NAME, 'bz2', 1703, 17, 1703, 20),
woosh.Token(woosh.NAME, 'import', 1703, 21, 1703, 27),
woosh.Token(woosh.NAME, 'BZ2File', 1703, 28, 1703, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 1703, 35, 1704, 0),
woosh.Token(woosh.DEDENT, ' ', 1704, 0, 1704, 8),
woosh.Token(woosh.NAME, 'except', 1704, 8, 1704, 14),
woosh.Token(woosh.NAME, 'ImportError', 1704, 15, 1704, 26),
woosh.Token(woosh.OP, ':', 1704, 26, 1704, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 1704, 27, 1705, 0),
woosh.Token(woosh.INDENT, ' ', 1705, 0, 1705, 12),
woosh.Token(woosh.NAME, 'raise', 1705, 12, 1705, 17),
woosh.Token(woosh.NAME, 'CompressionError', 1705, 18, 1705, 34),
woosh.Token(woosh.OP, '(', 1705, 34, 1705, 35),
woosh.Token(woosh.STRING, '"bz2 module is not available"', 1705, 35, 1705, 64),
woosh.Token(woosh.OP, ')', 1705, 64, 1705, 65),
woosh.Token(woosh.NEWLINE, '\r\n', 1705, 65, 1706, 0),
woosh.Token(woosh.DEDENT, ' ', 1707, 0, 1707, 8),
woosh.Token(woosh.NAME, 'fileobj', 1707, 8, 1707, 15),
woosh.Token(woosh.OP, '=', 1707, 16, 1707, 17),
woosh.Token(woosh.NAME, 'BZ2File', 1707, 18, 1707, 25),
woosh.Token(woosh.OP, '(', 1707, 25, 1707, 26),
woosh.Token(woosh.NAME, 'fileobj', 1707, 26, 1707, 33),
woosh.Token(woosh.NAME, 'or', 1707, 34, 1707, 36),
woosh.Token(woosh.NAME, 'name', 1707, 37, 1707, 41),
woosh.Token(woosh.OP, ',', 1707, 41, 1707, 42),
woosh.Token(woosh.NAME, 'mode', 1707, 43, 1707, 47),
woosh.Token(woosh.OP, ',', 1707, 47, 1707, 48),
woosh.Token(woosh.NAME, 'compresslevel', 1707, 49, 1707, 62),
woosh.Token(woosh.OP, '=', 1707, 62, 1707, 63),
woosh.Token(woosh.NAME, 'compresslevel', 1707, 63, 1707, 76),
woosh.Token(woosh.OP, ')', 1707, 76, 1707, 77),
woosh.Token(woosh.NEWLINE, '\r\n', 1707, 77, 1708, 0),
woosh.Token(woosh.NAME, 'try', 1709, 8, 1709, 11),
woosh.Token(woosh.OP, ':', 1709, 11, 1709, 12),
woosh.Token(woosh.NEWLINE, '\r\n', 1709, 12, 1710, 0),
woosh.Token(woosh.INDENT, ' ', 1710, 0, 1710, 12),
woosh.Token(woosh.NAME, 't', 1710, 12, 1710, 13),
woosh.Token(woosh.OP, '=', 1710, 14, 1710, 15),
woosh.Token(woosh.NAME, 'cls', 1710, 16, 1710, 19),
woosh.Token(woosh.OP, '.', 1710, 19, 1710, 20),
woosh.Token(woosh.NAME, 'taropen', 1710, 20, 1710, 27),
woosh.Token(woosh.OP, '(', 1710, 27, 1710, 28),
woosh.Token(woosh.NAME, 'name', 1710, 28, 1710, 32),
woosh.Token(woosh.OP, ',', 1710, 32, 1710, 33),
woosh.Token(woosh.NAME, 'mode', 1710, 34, 1710, 38),
woosh.Token(woosh.OP, ',', 1710, 38, 1710, 39),
woosh.Token(woosh.NAME, 'fileobj', 1710, 40, 1710, 47),
woosh.Token(woosh.OP, ',', 1710, 47, 1710, 48),
woosh.Token(woosh.OP, '**', 1710, 49, 1710, 51),
woosh.Token(woosh.NAME, 'kwargs', 1710, 51, 1710, 57),
woosh.Token(woosh.OP, ')', 1710, 57, 1710, 58),
woosh.Token(woosh.NEWLINE, '\r\n', 1710, 58, 1711, 0),
woosh.Token(woosh.DEDENT, ' ', 1711, 0, 1711, 8),
woosh.Token(woosh.NAME, 'except', 1711, 8, 1711, 14),
woosh.Token(woosh.OP, '(', 1711, 15, 1711, 16),
woosh.Token(woosh.NAME, 'OSError', 1711, 16, 1711, 23),
woosh.Token(woosh.OP, ',', 1711, 23, 1711, 24),
woosh.Token(woosh.NAME, 'EOFError', 1711, 25, 1711, 33),
woosh.Token(woosh.OP, ')', 1711, 33, 1711, 34),
woosh.Token(woosh.OP, ':', 1711, 34, 1711, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 1711, 35, 1712, 0),
woosh.Token(woosh.INDENT, ' ', 1712, 0, 1712, 12),
woosh.Token(woosh.NAME, 'fileobj', 1712, 12, 1712, 19),
woosh.Token(woosh.OP, '.', 1712, 19, 1712, 20),
woosh.Token(woosh.NAME, 'close', 1712, 20, 1712, 25),
woosh.Token(woosh.OP, '(', 1712, 25, 1712, 26),
woosh.Token(woosh.OP, ')', 1712, 26, 1712, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 1712, 27, 1713, 0),
woosh.Token(woosh.NAME, 'if', 1713, 12, 1713, 14),
woosh.Token(woosh.NAME, 'mode', 1713, 15, 1713, 19),
woosh.Token(woosh.OP, '==', 1713, 20, 1713, 22),
woosh.Token(woosh.STRING, "'r'", 1713, 23, 1713, 26),
woosh.Token(woosh.OP, ':', 1713, 26, 1713, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 1713, 27, 1714, 0),
woosh.Token(woosh.INDENT, ' ', 1714, 0, 1714, 16),
woosh.Token(woosh.NAME, 'raise', 1714, 16, 1714, 21),
woosh.Token(woosh.NAME, 'ReadError', 1714, 22, 1714, 31),
woosh.Token(woosh.OP, '(', 1714, 31, 1714, 32),
woosh.Token(woosh.STRING, '"not a bzip2 file"', 1714, 32, 1714, 50),
woosh.Token(woosh.OP, ')', 1714, 50, 1714, 51),
woosh.Token(woosh.NEWLINE, '\r\n', 1714, 51, 1715, 0),
woosh.Token(woosh.DEDENT, ' ', 1715, 0, 1715, 12),
woosh.Token(woosh.NAME, 'raise', 1715, 12, 1715, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 1715, 17, 1716, 0),
woosh.Token(woosh.DEDENT, ' ', 1716, 0, 1716, 8),
woosh.Token(woosh.NAME, 'except', 1716, 8, 1716, 14),
woosh.Token(woosh.OP, ':', 1716, 14, 1716, 15),
woosh.Token(woosh.NEWLINE, '\r\n', 1716, 15, 1717, 0),
woosh.Token(woosh.INDENT, ' ', 1717, 0, 1717, 12),
woosh.Token(woosh.NAME, 'fileobj', 1717, 12, 1717, 19),
woosh.Token(woosh.OP, '.', 1717, 19, 1717, 20),
woosh.Token(woosh.NAME, 'close', 1717, 20, 1717, 25),
woosh.Token(woosh.OP, '(', 1717, 25, 1717, 26),
woosh.Token(woosh.OP, ')', 1717, 26, 1717, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 1717, 27, 1718, 0),
woosh.Token(woosh.NAME, 'raise', 1718, 12, 1718, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 1718, 17, 1719, 0),
woosh.Token(woosh.DEDENT, ' ', 1719, 0, 1719, 8),
woosh.Token(woosh.NAME, 't', 1719, 8, 1719, 9),
woosh.Token(woosh.OP, '.', 1719, 9, 1719, 10),
woosh.Token(woosh.NAME, '_extfileobj', 1719, 10, 1719, 21),
woosh.Token(woosh.OP, '=', 1719, 22, 1719, 23),
woosh.Token(woosh.NAME, 'False', 1719, 24, 1719, 29),
woosh.Token(woosh.NEWLINE, '\r\n', 1719, 29, 1720, 0),
woosh.Token(woosh.NAME, 'return', 1720, 8, 1720, 14),
woosh.Token(woosh.NAME, 't', 1720, 15, 1720, 16),
woosh.Token(woosh.NEWLINE, '\r\n', 1720, 16, 1721, 0),
woosh.Token(woosh.DEDENT, ' ', 1722, 0, 1722, 4),
woosh.Token(woosh.OP, '@', 1722, 4, 1722, 5),
woosh.Token(woosh.NAME, 'classmethod', 1722, 5, 1722, 16),
woosh.Token(woosh.NEWLINE, '\r\n', 1722, 16, 1723, 0),
woosh.Token(woosh.NAME, 'def', 1723, 4, 1723, 7),
woosh.Token(woosh.NAME, 'xzopen', 1723, 8, 1723, 14),
woosh.Token(woosh.OP, '(', 1723, 14, 1723, 15),
woosh.Token(woosh.NAME, 'cls', 1723, 15, 1723, 18),
woosh.Token(woosh.OP, ',', 1723, 18, 1723, 19),
woosh.Token(woosh.NAME, 'name', 1723, 20, 1723, 24),
woosh.Token(woosh.OP, ',', 1723, 24, 1723, 25),
woosh.Token(woosh.NAME, 'mode', 1723, 26, 1723, 30),
woosh.Token(woosh.OP, '=', 1723, 30, 1723, 31),
woosh.Token(woosh.STRING, '"r"', 1723, 31, 1723, 34),
woosh.Token(woosh.OP, ',', 1723, 34, 1723, 35),
woosh.Token(woosh.NAME, 'fileobj', 1723, 36, 1723, 43),
woosh.Token(woosh.OP, '=', 1723, 43, 1723, 44),
woosh.Token(woosh.NAME, 'None', 1723, 44, 1723, 48),
woosh.Token(woosh.OP, ',', 1723, 48, 1723, 49),
woosh.Token(woosh.NAME, 'preset', 1723, 50, 1723, 56),
woosh.Token(woosh.OP, '=', 1723, 56, 1723, 57),
woosh.Token(woosh.NAME, 'None', 1723, 57, 1723, 61),
woosh.Token(woosh.OP, ',', 1723, 61, 1723, 62),
woosh.Token(woosh.OP, '**', 1723, 63, 1723, 65),
woosh.Token(woosh.NAME, 'kwargs', 1723, 65, 1723, 71),
woosh.Token(woosh.OP, ')', 1723, 71, 1723, 72),
woosh.Token(woosh.OP, ':', 1723, 72, 1723, 73),
woosh.Token(woosh.NEWLINE, '\r\n', 1723, 73, 1724, 0),
woosh.Token(woosh.INDENT, ' ', 1724, 0, 1724, 8),
woosh.Token(woosh.STRING, '"""Open lzma compressed tar archive name for reading or writing.\r\n Appending is not allowed.\r\n """', 1724, 8, 1726, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 1726, 11, 1727, 0),
woosh.Token(woosh.NAME, 'if', 1727, 8, 1727, 10),
woosh.Token(woosh.NAME, 'mode', 1727, 11, 1727, 15),
woosh.Token(woosh.NAME, 'not', 1727, 16, 1727, 19),
woosh.Token(woosh.NAME, 'in', 1727, 20, 1727, 22),
woosh.Token(woosh.OP, '(', 1727, 23, 1727, 24),
woosh.Token(woosh.STRING, '"r"', 1727, 24, 1727, 27),
woosh.Token(woosh.OP, ',', 1727, 27, 1727, 28),
woosh.Token(woosh.STRING, '"w"', 1727, 29, 1727, 32),
woosh.Token(woosh.OP, ',', 1727, 32, 1727, 33),
woosh.Token(woosh.STRING, '"x"', 1727, 34, 1727, 37),
woosh.Token(woosh.OP, ')', 1727, 37, 1727, 38),
woosh.Token(woosh.OP, ':', 1727, 38, 1727, 39),
woosh.Token(woosh.NEWLINE, '\r\n', 1727, 39, 1728, 0),
woosh.Token(woosh.INDENT, ' ', 1728, 0, 1728, 12),
woosh.Token(woosh.NAME, 'raise', 1728, 12, 1728, 17),
woosh.Token(woosh.NAME, 'ValueError', 1728, 18, 1728, 28),
woosh.Token(woosh.OP, '(', 1728, 28, 1728, 29),
woosh.Token(woosh.STRING, '"mode must be \'r\', \'w\' or \'x\'"', 1728, 29, 1728, 59),
woosh.Token(woosh.OP, ')', 1728, 59, 1728, 60),
woosh.Token(woosh.NEWLINE, '\r\n', 1728, 60, 1729, 0),
woosh.Token(woosh.DEDENT, ' ', 1730, 0, 1730, 8),
woosh.Token(woosh.NAME, 'try', 1730, 8, 1730, 11),
woosh.Token(woosh.OP, ':', 1730, 11, 1730, 12),
woosh.Token(woosh.NEWLINE, '\r\n', 1730, 12, 1731, 0),
woosh.Token(woosh.INDENT, ' ', 1731, 0, 1731, 12),
woosh.Token(woosh.NAME, 'from', 1731, 12, 1731, 16),
woosh.Token(woosh.NAME, 'lzma', 1731, 17, 1731, 21),
woosh.Token(woosh.NAME, 'import', 1731, 22, 1731, 28),
woosh.Token(woosh.NAME, 'LZMAFile', 1731, 29, 1731, 37),
woosh.Token(woosh.OP, ',', 1731, 37, 1731, 38),
woosh.Token(woosh.NAME, 'LZMAError', 1731, 39, 1731, 48),
woosh.Token(woosh.NEWLINE, '\r\n', 1731, 48, 1732, 0),
woosh.Token(woosh.DEDENT, ' ', 1732, 0, 1732, 8),
woosh.Token(woosh.NAME, 'except', 1732, 8, 1732, 14),
woosh.Token(woosh.NAME, 'ImportError', 1732, 15, 1732, 26),
woosh.Token(woosh.OP, ':', 1732, 26, 1732, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 1732, 27, 1733, 0),
woosh.Token(woosh.INDENT, ' ', 1733, 0, 1733, 12),
woosh.Token(woosh.NAME, 'raise', 1733, 12, 1733, 17),
woosh.Token(woosh.NAME, 'CompressionError', 1733, 18, 1733, 34),
woosh.Token(woosh.OP, '(', 1733, 34, 1733, 35),
woosh.Token(woosh.STRING, '"lzma module is not available"', 1733, 35, 1733, 65),
woosh.Token(woosh.OP, ')', 1733, 65, 1733, 66),
woosh.Token(woosh.NEWLINE, '\r\n', 1733, 66, 1734, 0),
woosh.Token(woosh.DEDENT, ' ', 1735, 0, 1735, 8),
woosh.Token(woosh.NAME, 'fileobj', 1735, 8, 1735, 15),
woosh.Token(woosh.OP, '=', 1735, 16, 1735, 17),
woosh.Token(woosh.NAME, 'LZMAFile', 1735, 18, 1735, 26),
woosh.Token(woosh.OP, '(', 1735, 26, 1735, 27),
woosh.Token(woosh.NAME, 'fileobj', 1735, 27, 1735, 34),
woosh.Token(woosh.NAME, 'or', 1735, 35, 1735, 37),
woosh.Token(woosh.NAME, 'name', 1735, 38, 1735, 42),
woosh.Token(woosh.OP, ',', 1735, 42, 1735, 43),
woosh.Token(woosh.NAME, 'mode', 1735, 44, 1735, 48),
woosh.Token(woosh.OP, ',', 1735, 48, 1735, 49),
woosh.Token(woosh.NAME, 'preset', 1735, 50, 1735, 56),
woosh.Token(woosh.OP, '=', 1735, 56, 1735, 57),
woosh.Token(woosh.NAME, 'preset', 1735, 57, 1735, 63),
woosh.Token(woosh.OP, ')', 1735, 63, 1735, 64),
woosh.Token(woosh.NEWLINE, '\r\n', 1735, 64, 1736, 0),
woosh.Token(woosh.NAME, 'try', 1737, 8, 1737, 11),
woosh.Token(woosh.OP, ':', 1737, 11, 1737, 12),
woosh.Token(woosh.NEWLINE, '\r\n', 1737, 12, 1738, 0),
woosh.Token(woosh.INDENT, ' ', 1738, 0, 1738, 12),
woosh.Token(woosh.NAME, 't', 1738, 12, 1738, 13),
woosh.Token(woosh.OP, '=', 1738, 14, 1738, 15),
woosh.Token(woosh.NAME, 'cls', 1738, 16, 1738, 19),
woosh.Token(woosh.OP, '.', 1738, 19, 1738, 20),
woosh.Token(woosh.NAME, 'taropen', 1738, 20, 1738, 27),
woosh.Token(woosh.OP, '(', 1738, 27, 1738, 28),
woosh.Token(woosh.NAME, 'name', 1738, 28, 1738, 32),
woosh.Token(woosh.OP, ',', 1738, 32, 1738, 33),
woosh.Token(woosh.NAME, 'mode', 1738, 34, 1738, 38),
woosh.Token(woosh.OP, ',', 1738, 38, 1738, 39),
woosh.Token(woosh.NAME, 'fileobj', 1738, 40, 1738, 47),
woosh.Token(woosh.OP, ',', 1738, 47, 1738, 48),
woosh.Token(woosh.OP, '**', 1738, 49, 1738, 51),
woosh.Token(woosh.NAME, 'kwargs', 1738, 51, 1738, 57),
woosh.Token(woosh.OP, ')', 1738, 57, 1738, 58),
woosh.Token(woosh.NEWLINE, '\r\n', 1738, 58, 1739, 0),
woosh.Token(woosh.DEDENT, ' ', 1739, 0, 1739, 8),
woosh.Token(woosh.NAME, 'except', 1739, 8, 1739, 14),
woosh.Token(woosh.OP, '(', 1739, 15, 1739, 16),
woosh.Token(woosh.NAME, 'LZMAError', 1739, 16, 1739, 25),
woosh.Token(woosh.OP, ',', 1739, 25, 1739, 26),
woosh.Token(woosh.NAME, 'EOFError', 1739, 27, 1739, 35),
woosh.Token(woosh.OP, ')', 1739, 35, 1739, 36),
woosh.Token(woosh.OP, ':', 1739, 36, 1739, 37),
woosh.Token(woosh.NEWLINE, '\r\n', 1739, 37, 1740, 0),
woosh.Token(woosh.INDENT, ' ', 1740, 0, 1740, 12),
woosh.Token(woosh.NAME, 'fileobj', 1740, 12, 1740, 19),
woosh.Token(woosh.OP, '.', 1740, 19, 1740, 20),
woosh.Token(woosh.NAME, 'close', 1740, 20, 1740, 25),
woosh.Token(woosh.OP, '(', 1740, 25, 1740, 26),
woosh.Token(woosh.OP, ')', 1740, 26, 1740, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 1740, 27, 1741, 0),
woosh.Token(woosh.NAME, 'if', 1741, 12, 1741, 14),
woosh.Token(woosh.NAME, 'mode', 1741, 15, 1741, 19),
woosh.Token(woosh.OP, '==', 1741, 20, 1741, 22),
woosh.Token(woosh.STRING, "'r'", 1741, 23, 1741, 26),
woosh.Token(woosh.OP, ':', 1741, 26, 1741, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 1741, 27, 1742, 0),
woosh.Token(woosh.INDENT, ' ', 1742, 0, 1742, 16),
woosh.Token(woosh.NAME, 'raise', 1742, 16, 1742, 21),
woosh.Token(woosh.NAME, 'ReadError', 1742, 22, 1742, 31),
woosh.Token(woosh.OP, '(', 1742, 31, 1742, 32),
woosh.Token(woosh.STRING, '"not an lzma file"', 1742, 32, 1742, 50),
woosh.Token(woosh.OP, ')', 1742, 50, 1742, 51),
woosh.Token(woosh.NEWLINE, '\r\n', 1742, 51, 1743, 0),
woosh.Token(woosh.DEDENT, ' ', 1743, 0, 1743, 12),
woosh.Token(woosh.NAME, 'raise', 1743, 12, 1743, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 1743, 17, 1744, 0),
woosh.Token(woosh.DEDENT, ' ', 1744, 0, 1744, 8),
woosh.Token(woosh.NAME, 'except', 1744, 8, 1744, 14),
woosh.Token(woosh.OP, ':', 1744, 14, 1744, 15),
woosh.Token(woosh.NEWLINE, '\r\n', 1744, 15, 1745, 0),
woosh.Token(woosh.INDENT, ' ', 1745, 0, 1745, 12),
woosh.Token(woosh.NAME, 'fileobj', 1745, 12, 1745, 19),
woosh.Token(woosh.OP, '.', 1745, 19, 1745, 20),
woosh.Token(woosh.NAME, 'close', 1745, 20, 1745, 25),
woosh.Token(woosh.OP, '(', 1745, 25, 1745, 26),
woosh.Token(woosh.OP, ')', 1745, 26, 1745, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 1745, 27, 1746, 0),
woosh.Token(woosh.NAME, 'raise', 1746, 12, 1746, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 1746, 17, 1747, 0),
woosh.Token(woosh.DEDENT, ' ', 1747, 0, 1747, 8),
woosh.Token(woosh.NAME, 't', 1747, 8, 1747, 9),
woosh.Token(woosh.OP, '.', 1747, 9, 1747, 10),
woosh.Token(woosh.NAME, '_extfileobj', 1747, 10, 1747, 21),
woosh.Token(woosh.OP, '=', 1747, 22, 1747, 23),
woosh.Token(woosh.NAME, 'False', 1747, 24, 1747, 29),
woosh.Token(woosh.NEWLINE, '\r\n', 1747, 29, 1748, 0),
woosh.Token(woosh.NAME, 'return', 1748, 8, 1748, 14),
woosh.Token(woosh.NAME, 't', 1748, 15, 1748, 16),
woosh.Token(woosh.NEWLINE, '\r\n', 1748, 16, 1749, 0),
woosh.Token(woosh.COMMENT, '# All *open() methods are registered here.', 1750, 4, 1750, 46),
woosh.Token(woosh.DEDENT, ' ', 1751, 0, 1751, 4),
woosh.Token(woosh.NAME, 'OPEN_METH', 1751, 4, 1751, 13),
woosh.Token(woosh.OP, '=', 1751, 14, 1751, 15),
woosh.Token(woosh.OP, '{', 1751, 16, 1751, 17),
woosh.Token(woosh.STRING, '"tar"', 1752, 8, 1752, 13),
woosh.Token(woosh.OP, ':', 1752, 13, 1752, 14),
woosh.Token(woosh.STRING, '"taropen"', 1752, 15, 1752, 24),
woosh.Token(woosh.OP, ',', 1752, 24, 1752, 25),
woosh.Token(woosh.COMMENT, '# uncompressed tar', 1752, 28, 1752, 46),
woosh.Token(woosh.STRING, '"gz"', 1753, 8, 1753, 12),
woosh.Token(woosh.OP, ':', 1753, 12, 1753, 13),
woosh.Token(woosh.STRING, '"gzopen"', 1753, 15, 1753, 23),
woosh.Token(woosh.OP, ',', 1753, 23, 1753, 24),
woosh.Token(woosh.COMMENT, '# gzip compressed tar', 1753, 28, 1753, 49),
woosh.Token(woosh.STRING, '"bz2"', 1754, 8, 1754, 13),
woosh.Token(woosh.OP, ':', 1754, 13, 1754, 14),
woosh.Token(woosh.STRING, '"bz2open"', 1754, 15, 1754, 24),
woosh.Token(woosh.OP, ',', 1754, 24, 1754, 25),
woosh.Token(woosh.COMMENT, '# bzip2 compressed tar', 1754, 28, 1754, 50),
woosh.Token(woosh.STRING, '"xz"', 1755, 8, 1755, 12),
woosh.Token(woosh.OP, ':', 1755, 12, 1755, 13),
woosh.Token(woosh.STRING, '"xzopen"', 1755, 15, 1755, 23),
woosh.Token(woosh.COMMENT, '# lzma compressed tar', 1755, 28, 1755, 49),
woosh.Token(woosh.OP, '}', 1756, 4, 1756, 5),
woosh.Token(woosh.NEWLINE, '\r\n', 1756, 5, 1757, 0),
woosh.Token(woosh.COMMENT, '#--------------------------------------------------------------------------', 1758, 4, 1758, 79),
woosh.Token(woosh.COMMENT, '# The public methods which TarFile provides:', 1759, 4, 1759, 48),
woosh.Token(woosh.NAME, 'def', 1761, 4, 1761, 7),
woosh.Token(woosh.NAME, 'close', 1761, 8, 1761, 13),
woosh.Token(woosh.OP, '(', 1761, 13, 1761, 14),
woosh.Token(woosh.NAME, 'self', 1761, 14, 1761, 18),
woosh.Token(woosh.OP, ')', 1761, 18, 1761, 19),
woosh.Token(woosh.OP, ':', 1761, 19, 1761, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 1761, 20, 1762, 0),
woosh.Token(woosh.INDENT, ' ', 1762, 0, 1762, 8),
woosh.Token(woosh.STRING, '"""Close the TarFile. In write-mode, two finishing zero blocks are\r\n appended to the archive.\r\n """', 1762, 8, 1764, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 1764, 11, 1765, 0),
woosh.Token(woosh.NAME, 'if', 1765, 8, 1765, 10),
woosh.Token(woosh.NAME, 'self', 1765, 11, 1765, 15),
woosh.Token(woosh.OP, '.', 1765, 15, 1765, 16),
woosh.Token(woosh.NAME, 'closed', 1765, 16, 1765, 22),
woosh.Token(woosh.OP, ':', 1765, 22, 1765, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 1765, 23, 1766, 0),
woosh.Token(woosh.INDENT, ' ', 1766, 0, 1766, 12),
woosh.Token(woosh.NAME, 'return', 1766, 12, 1766, 18),
woosh.Token(woosh.NEWLINE, '\r\n', 1766, 18, 1767, 0),
woosh.Token(woosh.DEDENT, ' ', 1768, 0, 1768, 8),
woosh.Token(woosh.NAME, 'self', 1768, 8, 1768, 12),
woosh.Token(woosh.OP, '.', 1768, 12, 1768, 13),
woosh.Token(woosh.NAME, 'closed', 1768, 13, 1768, 19),
woosh.Token(woosh.OP, '=', 1768, 20, 1768, 21),
woosh.Token(woosh.NAME, 'True', 1768, 22, 1768, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 1768, 26, 1769, 0),
woosh.Token(woosh.NAME, 'try', 1769, 8, 1769, 11),
woosh.Token(woosh.OP, ':', 1769, 11, 1769, 12),
woosh.Token(woosh.NEWLINE, '\r\n', 1769, 12, 1770, 0),
woosh.Token(woosh.INDENT, ' ', 1770, 0, 1770, 12),
woosh.Token(woosh.NAME, 'if', 1770, 12, 1770, 14),
woosh.Token(woosh.NAME, 'self', 1770, 15, 1770, 19),
woosh.Token(woosh.OP, '.', 1770, 19, 1770, 20),
woosh.Token(woosh.NAME, 'mode', 1770, 20, 1770, 24),
woosh.Token(woosh.NAME, 'in', 1770, 25, 1770, 27),
woosh.Token(woosh.OP, '(', 1770, 28, 1770, 29),
woosh.Token(woosh.STRING, '"a"', 1770, 29, 1770, 32),
woosh.Token(woosh.OP, ',', 1770, 32, 1770, 33),
woosh.Token(woosh.STRING, '"w"', 1770, 34, 1770, 37),
woosh.Token(woosh.OP, ',', 1770, 37, 1770, 38),
woosh.Token(woosh.STRING, '"x"', 1770, 39, 1770, 42),
woosh.Token(woosh.OP, ')', 1770, 42, 1770, 43),
woosh.Token(woosh.OP, ':', 1770, 43, 1770, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 1770, 44, 1771, 0),
woosh.Token(woosh.INDENT, ' ', 1771, 0, 1771, 16),
woosh.Token(woosh.NAME, 'self', 1771, 16, 1771, 20),
woosh.Token(woosh.OP, '.', 1771, 20, 1771, 21),
woosh.Token(woosh.NAME, 'fileobj', 1771, 21, 1771, 28),
woosh.Token(woosh.OP, '.', 1771, 28, 1771, 29),
woosh.Token(woosh.NAME, 'write', 1771, 29, 1771, 34),
woosh.Token(woosh.OP, '(', 1771, 34, 1771, 35),
woosh.Token(woosh.NAME, 'NUL', 1771, 35, 1771, 38),
woosh.Token(woosh.OP, '*', 1771, 39, 1771, 40),
woosh.Token(woosh.OP, '(', 1771, 41, 1771, 42),
woosh.Token(woosh.NAME, 'BLOCKSIZE', 1771, 42, 1771, 51),
woosh.Token(woosh.OP, '*', 1771, 52, 1771, 53),
woosh.Token(woosh.NUMBER, '2', 1771, 54, 1771, 55),
woosh.Token(woosh.OP, ')', 1771, 55, 1771, 56),
woosh.Token(woosh.OP, ')', 1771, 56, 1771, 57),
woosh.Token(woosh.NEWLINE, '\r\n', 1771, 57, 1772, 0),
woosh.Token(woosh.NAME, 'self', 1772, 16, 1772, 20),
woosh.Token(woosh.OP, '.', 1772, 20, 1772, 21),
woosh.Token(woosh.NAME, 'offset', 1772, 21, 1772, 27),
woosh.Token(woosh.OP, '+=', 1772, 28, 1772, 30),
woosh.Token(woosh.OP, '(', 1772, 31, 1772, 32),
woosh.Token(woosh.NAME, 'BLOCKSIZE', 1772, 32, 1772, 41),
woosh.Token(woosh.OP, '*', 1772, 42, 1772, 43),
woosh.Token(woosh.NUMBER, '2', 1772, 44, 1772, 45),
woosh.Token(woosh.OP, ')', 1772, 45, 1772, 46),
woosh.Token(woosh.NEWLINE, '\r\n', 1772, 46, 1773, 0),
woosh.Token(woosh.COMMENT, '# fill up the end with zero-blocks', 1773, 16, 1773, 50),
woosh.Token(woosh.COMMENT, '# (like option -b20 for tar does)', 1774, 16, 1774, 49),
woosh.Token(woosh.NAME, 'blocks', 1775, 16, 1775, 22),
woosh.Token(woosh.OP, ',', 1775, 22, 1775, 23),
woosh.Token(woosh.NAME, 'remainder', 1775, 24, 1775, 33),
woosh.Token(woosh.OP, '=', 1775, 34, 1775, 35),
woosh.Token(woosh.NAME, 'divmod', 1775, 36, 1775, 42),
woosh.Token(woosh.OP, '(', 1775, 42, 1775, 43),
woosh.Token(woosh.NAME, 'self', 1775, 43, 1775, 47),
woosh.Token(woosh.OP, '.', 1775, 47, 1775, 48),
woosh.Token(woosh.NAME, 'offset', 1775, 48, 1775, 54),
woosh.Token(woosh.OP, ',', 1775, 54, 1775, 55),
woosh.Token(woosh.NAME, 'RECORDSIZE', 1775, 56, 1775, 66),
woosh.Token(woosh.OP, ')', 1775, 66, 1775, 67),
woosh.Token(woosh.NEWLINE, '\r\n', 1775, 67, 1776, 0),
woosh.Token(woosh.NAME, 'if', 1776, 16, 1776, 18),
woosh.Token(woosh.NAME, 'remainder', 1776, 19, 1776, 28),
woosh.Token(woosh.OP, '>', 1776, 29, 1776, 30),
woosh.Token(woosh.NUMBER, '0', 1776, 31, 1776, 32),
woosh.Token(woosh.OP, ':', 1776, 32, 1776, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 1776, 33, 1777, 0),
woosh.Token(woosh.INDENT, ' ', 1777, 0, 1777, 20),
woosh.Token(woosh.NAME, 'self', 1777, 20, 1777, 24),
woosh.Token(woosh.OP, '.', 1777, 24, 1777, 25),
woosh.Token(woosh.NAME, 'fileobj', 1777, 25, 1777, 32),
woosh.Token(woosh.OP, '.', 1777, 32, 1777, 33),
woosh.Token(woosh.NAME, 'write', 1777, 33, 1777, 38),
woosh.Token(woosh.OP, '(', 1777, 38, 1777, 39),
woosh.Token(woosh.NAME, 'NUL', 1777, 39, 1777, 42),
woosh.Token(woosh.OP, '*', 1777, 43, 1777, 44),
woosh.Token(woosh.OP, '(', 1777, 45, 1777, 46),
woosh.Token(woosh.NAME, 'RECORDSIZE', 1777, 46, 1777, 56),
woosh.Token(woosh.OP, '-', 1777, 57, 1777, 58),
woosh.Token(woosh.NAME, 'remainder', 1777, 59, 1777, 68),
woosh.Token(woosh.OP, ')', 1777, 68, 1777, 69),
woosh.Token(woosh.OP, ')', 1777, 69, 1777, 70),
woosh.Token(woosh.NEWLINE, '\r\n', 1777, 70, 1778, 0),
woosh.Token(woosh.DEDENT, ' ', 1778, 0, 1778, 8),
woosh.Token(woosh.DEDENT, '', 1778, 8, 1778, 8),
woosh.Token(woosh.DEDENT, '', 1778, 8, 1778, 8),
woosh.Token(woosh.NAME, 'finally', 1778, 8, 1778, 15),
woosh.Token(woosh.OP, ':', 1778, 15, 1778, 16),
woosh.Token(woosh.NEWLINE, '\r\n', 1778, 16, 1779, 0),
woosh.Token(woosh.INDENT, ' ', 1779, 0, 1779, 12),
woosh.Token(woosh.NAME, 'if', 1779, 12, 1779, 14),
woosh.Token(woosh.NAME, 'not', 1779, 15, 1779, 18),
woosh.Token(woosh.NAME, 'self', 1779, 19, 1779, 23),
woosh.Token(woosh.OP, '.', 1779, 23, 1779, 24),
woosh.Token(woosh.NAME, '_extfileobj', 1779, 24, 1779, 35),
woosh.Token(woosh.OP, ':', 1779, 35, 1779, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 1779, 36, 1780, 0),
woosh.Token(woosh.INDENT, ' ', 1780, 0, 1780, 16),
woosh.Token(woosh.NAME, 'self', 1780, 16, 1780, 20),
woosh.Token(woosh.OP, '.', 1780, 20, 1780, 21),
woosh.Token(woosh.NAME, 'fileobj', 1780, 21, 1780, 28),
woosh.Token(woosh.OP, '.', 1780, 28, 1780, 29),
woosh.Token(woosh.NAME, 'close', 1780, 29, 1780, 34),
woosh.Token(woosh.OP, '(', 1780, 34, 1780, 35),
woosh.Token(woosh.OP, ')', 1780, 35, 1780, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 1780, 36, 1781, 0),
woosh.Token(woosh.DEDENT, ' ', 1782, 0, 1782, 4),
woosh.Token(woosh.DEDENT, '', 1782, 4, 1782, 4),
woosh.Token(woosh.DEDENT, '', 1782, 4, 1782, 4),
woosh.Token(woosh.NAME, 'def', 1782, 4, 1782, 7),
woosh.Token(woosh.NAME, 'getmember', 1782, 8, 1782, 17),
woosh.Token(woosh.OP, '(', 1782, 17, 1782, 18),
woosh.Token(woosh.NAME, 'self', 1782, 18, 1782, 22),
woosh.Token(woosh.OP, ',', 1782, 22, 1782, 23),
woosh.Token(woosh.NAME, 'name', 1782, 24, 1782, 28),
woosh.Token(woosh.OP, ')', 1782, 28, 1782, 29),
woosh.Token(woosh.OP, ':', 1782, 29, 1782, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 1782, 30, 1783, 0),
woosh.Token(woosh.INDENT, ' ', 1783, 0, 1783, 8),
woosh.Token(woosh.STRING, '"""Return a TarInfo object for member `name\'. If `name\' can not be\r\n found in the archive, KeyError is raised. If a member occurs more\r\n than once in the archive, its last occurrence is assumed to be the\r\n most up-to-date version.\r\n """', 1783, 8, 1787, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 1787, 11, 1788, 0),
woosh.Token(woosh.NAME, 'tarinfo', 1788, 8, 1788, 15),
woosh.Token(woosh.OP, '=', 1788, 16, 1788, 17),
woosh.Token(woosh.NAME, 'self', 1788, 18, 1788, 22),
woosh.Token(woosh.OP, '.', 1788, 22, 1788, 23),
woosh.Token(woosh.NAME, '_getmember', 1788, 23, 1788, 33),
woosh.Token(woosh.OP, '(', 1788, 33, 1788, 34),
woosh.Token(woosh.NAME, 'name', 1788, 34, 1788, 38),
woosh.Token(woosh.OP, ')', 1788, 38, 1788, 39),
woosh.Token(woosh.NEWLINE, '\r\n', 1788, 39, 1789, 0),
woosh.Token(woosh.NAME, 'if', 1789, 8, 1789, 10),
woosh.Token(woosh.NAME, 'tarinfo', 1789, 11, 1789, 18),
woosh.Token(woosh.NAME, 'is', 1789, 19, 1789, 21),
woosh.Token(woosh.NAME, 'None', 1789, 22, 1789, 26),
woosh.Token(woosh.OP, ':', 1789, 26, 1789, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 1789, 27, 1790, 0),
woosh.Token(woosh.INDENT, ' ', 1790, 0, 1790, 12),
woosh.Token(woosh.NAME, 'raise', 1790, 12, 1790, 17),
woosh.Token(woosh.NAME, 'KeyError', 1790, 18, 1790, 26),
woosh.Token(woosh.OP, '(', 1790, 26, 1790, 27),
woosh.Token(woosh.STRING, '"filename %r not found"', 1790, 27, 1790, 50),
woosh.Token(woosh.OP, '%', 1790, 51, 1790, 52),
woosh.Token(woosh.NAME, 'name', 1790, 53, 1790, 57),
woosh.Token(woosh.OP, ')', 1790, 57, 1790, 58),
woosh.Token(woosh.NEWLINE, '\r\n', 1790, 58, 1791, 0),
woosh.Token(woosh.DEDENT, ' ', 1791, 0, 1791, 8),
woosh.Token(woosh.NAME, 'return', 1791, 8, 1791, 14),
woosh.Token(woosh.NAME, 'tarinfo', 1791, 15, 1791, 22),
woosh.Token(woosh.NEWLINE, '\r\n', 1791, 22, 1792, 0),
woosh.Token(woosh.DEDENT, ' ', 1793, 0, 1793, 4),
woosh.Token(woosh.NAME, 'def', 1793, 4, 1793, 7),
woosh.Token(woosh.NAME, 'getmembers', 1793, 8, 1793, 18),
woosh.Token(woosh.OP, '(', 1793, 18, 1793, 19),
woosh.Token(woosh.NAME, 'self', 1793, 19, 1793, 23),
woosh.Token(woosh.OP, ')', 1793, 23, 1793, 24),
woosh.Token(woosh.OP, ':', 1793, 24, 1793, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 1793, 25, 1794, 0),
woosh.Token(woosh.INDENT, ' ', 1794, 0, 1794, 8),
woosh.Token(woosh.STRING, '"""Return the members of the archive as a list of TarInfo objects. The\r\n list has the same order as the members in the archive.\r\n """', 1794, 8, 1796, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 1796, 11, 1797, 0),
woosh.Token(woosh.NAME, 'self', 1797, 8, 1797, 12),
woosh.Token(woosh.OP, '.', 1797, 12, 1797, 13),
woosh.Token(woosh.NAME, '_check', 1797, 13, 1797, 19),
woosh.Token(woosh.OP, '(', 1797, 19, 1797, 20),
woosh.Token(woosh.OP, ')', 1797, 20, 1797, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 1797, 21, 1798, 0),
woosh.Token(woosh.NAME, 'if', 1798, 8, 1798, 10),
woosh.Token(woosh.NAME, 'not', 1798, 11, 1798, 14),
woosh.Token(woosh.NAME, 'self', 1798, 15, 1798, 19),
woosh.Token(woosh.OP, '.', 1798, 19, 1798, 20),
woosh.Token(woosh.NAME, '_loaded', 1798, 20, 1798, 27),
woosh.Token(woosh.OP, ':', 1798, 27, 1798, 28),
woosh.Token(woosh.COMMENT, '# if we want to obtain a list of', 1798, 32, 1798, 64),
woosh.Token(woosh.NEWLINE, '\r\n', 1798, 64, 1799, 0),
woosh.Token(woosh.INDENT, ' ', 1799, 0, 1799, 12),
woosh.Token(woosh.NAME, 'self', 1799, 12, 1799, 16),
woosh.Token(woosh.OP, '.', 1799, 16, 1799, 17),
woosh.Token(woosh.NAME, '_load', 1799, 17, 1799, 22),
woosh.Token(woosh.OP, '(', 1799, 22, 1799, 23),
woosh.Token(woosh.OP, ')', 1799, 23, 1799, 24),
woosh.Token(woosh.COMMENT, '# all members, we first have to', 1799, 32, 1799, 63),
woosh.Token(woosh.NEWLINE, '\r\n', 1799, 63, 1800, 0),
woosh.Token(woosh.COMMENT, '# scan the whole archive.', 1800, 32, 1800, 57),
woosh.Token(woosh.DEDENT, ' ', 1801, 0, 1801, 8),
woosh.Token(woosh.NAME, 'return', 1801, 8, 1801, 14),
woosh.Token(woosh.NAME, 'self', 1801, 15, 1801, 19),
woosh.Token(woosh.OP, '.', 1801, 19, 1801, 20),
woosh.Token(woosh.NAME, 'members', 1801, 20, 1801, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 1801, 27, 1802, 0),
woosh.Token(woosh.DEDENT, ' ', 1803, 0, 1803, 4),
woosh.Token(woosh.NAME, 'def', 1803, 4, 1803, 7),
woosh.Token(woosh.NAME, 'getnames', 1803, 8, 1803, 16),
woosh.Token(woosh.OP, '(', 1803, 16, 1803, 17),
woosh.Token(woosh.NAME, 'self', 1803, 17, 1803, 21),
woosh.Token(woosh.OP, ')', 1803, 21, 1803, 22),
woosh.Token(woosh.OP, ':', 1803, 22, 1803, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 1803, 23, 1804, 0),
woosh.Token(woosh.INDENT, ' ', 1804, 0, 1804, 8),
woosh.Token(woosh.STRING, '"""Return the members of the archive as a list of their names. It has\r\n the same order as the list returned by getmembers().\r\n """', 1804, 8, 1806, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 1806, 11, 1807, 0),
woosh.Token(woosh.NAME, 'return', 1807, 8, 1807, 14),
woosh.Token(woosh.OP, '[', 1807, 15, 1807, 16),
woosh.Token(woosh.NAME, 'tarinfo', 1807, 16, 1807, 23),
woosh.Token(woosh.OP, '.', 1807, 23, 1807, 24),
woosh.Token(woosh.NAME, 'name', 1807, 24, 1807, 28),
woosh.Token(woosh.NAME, 'for', 1807, 29, 1807, 32),
woosh.Token(woosh.NAME, 'tarinfo', 1807, 33, 1807, 40),
woosh.Token(woosh.NAME, 'in', 1807, 41, 1807, 43),
woosh.Token(woosh.NAME, 'self', 1807, 44, 1807, 48),
woosh.Token(woosh.OP, '.', 1807, 48, 1807, 49),
woosh.Token(woosh.NAME, 'getmembers', 1807, 49, 1807, 59),
woosh.Token(woosh.OP, '(', 1807, 59, 1807, 60),
woosh.Token(woosh.OP, ')', 1807, 60, 1807, 61),
woosh.Token(woosh.OP, ']', 1807, 61, 1807, 62),
woosh.Token(woosh.NEWLINE, '\r\n', 1807, 62, 1808, 0),
woosh.Token(woosh.DEDENT, ' ', 1809, 0, 1809, 4),
woosh.Token(woosh.NAME, 'def', 1809, 4, 1809, 7),
woosh.Token(woosh.NAME, 'gettarinfo', 1809, 8, 1809, 18),
woosh.Token(woosh.OP, '(', 1809, 18, 1809, 19),
woosh.Token(woosh.NAME, 'self', 1809, 19, 1809, 23),
woosh.Token(woosh.OP, ',', 1809, 23, 1809, 24),
woosh.Token(woosh.NAME, 'name', 1809, 25, 1809, 29),
woosh.Token(woosh.OP, '=', 1809, 29, 1809, 30),
woosh.Token(woosh.NAME, 'None', 1809, 30, 1809, 34),
woosh.Token(woosh.OP, ',', 1809, 34, 1809, 35),
woosh.Token(woosh.NAME, 'arcname', 1809, 36, 1809, 43),
woosh.Token(woosh.OP, '=', 1809, 43, 1809, 44),
woosh.Token(woosh.NAME, 'None', 1809, 44, 1809, 48),
woosh.Token(woosh.OP, ',', 1809, 48, 1809, 49),
woosh.Token(woosh.NAME, 'fileobj', 1809, 50, 1809, 57),
woosh.Token(woosh.OP, '=', 1809, 57, 1809, 58),
woosh.Token(woosh.NAME, 'None', 1809, 58, 1809, 62),
woosh.Token(woosh.OP, ')', 1809, 62, 1809, 63),
woosh.Token(woosh.OP, ':', 1809, 63, 1809, 64),
woosh.Token(woosh.NEWLINE, '\r\n', 1809, 64, 1810, 0),
woosh.Token(woosh.INDENT, ' ', 1810, 0, 1810, 8),
woosh.Token(woosh.STRING, '"""Create a TarInfo object from the result of os.stat or equivalent\r\n on an existing file. The file is either named by `name\', or\r\n specified as a file object `fileobj\' with a file descriptor. If\r\n given, `arcname\' specifies an alternative name for the file in the\r\n archive, otherwise, the name is taken from the \'name\' attribute of\r\n \'fileobj\', or the \'name\' argument. The name should be a text\r\n string.\r\n """', 1810, 8, 1817, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 1817, 11, 1818, 0),
woosh.Token(woosh.NAME, 'self', 1818, 8, 1818, 12),
woosh.Token(woosh.OP, '.', 1818, 12, 1818, 13),
woosh.Token(woosh.NAME, '_check', 1818, 13, 1818, 19),
woosh.Token(woosh.OP, '(', 1818, 19, 1818, 20),
woosh.Token(woosh.STRING, '"awx"', 1818, 20, 1818, 25),
woosh.Token(woosh.OP, ')', 1818, 25, 1818, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 1818, 26, 1819, 0),
woosh.Token(woosh.COMMENT, '# When fileobj is given, replace name by', 1820, 8, 1820, 48),
woosh.Token(woosh.COMMENT, "# fileobj's real name.", 1821, 8, 1821, 30),
woosh.Token(woosh.NAME, 'if', 1822, 8, 1822, 10),
woosh.Token(woosh.NAME, 'fileobj', 1822, 11, 1822, 18),
woosh.Token(woosh.NAME, 'is', 1822, 19, 1822, 21),
woosh.Token(woosh.NAME, 'not', 1822, 22, 1822, 25),
woosh.Token(woosh.NAME, 'None', 1822, 26, 1822, 30),
woosh.Token(woosh.OP, ':', 1822, 30, 1822, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 1822, 31, 1823, 0),
woosh.Token(woosh.INDENT, ' ', 1823, 0, 1823, 12),
woosh.Token(woosh.NAME, 'name', 1823, 12, 1823, 16),
woosh.Token(woosh.OP, '=', 1823, 17, 1823, 18),
woosh.Token(woosh.NAME, 'fileobj', 1823, 19, 1823, 26),
woosh.Token(woosh.OP, '.', 1823, 26, 1823, 27),
woosh.Token(woosh.NAME, 'name', 1823, 27, 1823, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 1823, 31, 1824, 0),
woosh.Token(woosh.COMMENT, '# Building the name of the member in the archive.', 1825, 8, 1825, 57),
woosh.Token(woosh.COMMENT, '# Backward slashes are converted to forward slashes,', 1826, 8, 1826, 60),
woosh.Token(woosh.COMMENT, '# Absolute paths are turned to relative paths.', 1827, 8, 1827, 54),
woosh.Token(woosh.DEDENT, ' ', 1828, 0, 1828, 8),
woosh.Token(woosh.NAME, 'if', 1828, 8, 1828, 10),
woosh.Token(woosh.NAME, 'arcname', 1828, 11, 1828, 18),
woosh.Token(woosh.NAME, 'is', 1828, 19, 1828, 21),
woosh.Token(woosh.NAME, 'None', 1828, 22, 1828, 26),
woosh.Token(woosh.OP, ':', 1828, 26, 1828, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 1828, 27, 1829, 0),
woosh.Token(woosh.INDENT, ' ', 1829, 0, 1829, 12),
woosh.Token(woosh.NAME, 'arcname', 1829, 12, 1829, 19),
woosh.Token(woosh.OP, '=', 1829, 20, 1829, 21),
woosh.Token(woosh.NAME, 'name', 1829, 22, 1829, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 1829, 26, 1830, 0),
woosh.Token(woosh.DEDENT, ' ', 1830, 0, 1830, 8),
woosh.Token(woosh.NAME, 'drv', 1830, 8, 1830, 11),
woosh.Token(woosh.OP, ',', 1830, 11, 1830, 12),
woosh.Token(woosh.NAME, 'arcname', 1830, 13, 1830, 20),
woosh.Token(woosh.OP, '=', 1830, 21, 1830, 22),
woosh.Token(woosh.NAME, 'os', 1830, 23, 1830, 25),
woosh.Token(woosh.OP, '.', 1830, 25, 1830, 26),
woosh.Token(woosh.NAME, 'path', 1830, 26, 1830, 30),
woosh.Token(woosh.OP, '.', 1830, 30, 1830, 31),
woosh.Token(woosh.NAME, 'splitdrive', 1830, 31, 1830, 41),
woosh.Token(woosh.OP, '(', 1830, 41, 1830, 42),
woosh.Token(woosh.NAME, 'arcname', 1830, 42, 1830, 49),
woosh.Token(woosh.OP, ')', 1830, 49, 1830, 50),
woosh.Token(woosh.NEWLINE, '\r\n', 1830, 50, 1831, 0),
woosh.Token(woosh.NAME, 'arcname', 1831, 8, 1831, 15),
woosh.Token(woosh.OP, '=', 1831, 16, 1831, 17),
woosh.Token(woosh.NAME, 'arcname', 1831, 18, 1831, 25),
woosh.Token(woosh.OP, '.', 1831, 25, 1831, 26),
woosh.Token(woosh.NAME, 'replace', 1831, 26, 1831, 33),
woosh.Token(woosh.OP, '(', 1831, 33, 1831, 34),
woosh.Token(woosh.NAME, 'os', 1831, 34, 1831, 36),
woosh.Token(woosh.OP, '.', 1831, 36, 1831, 37),
woosh.Token(woosh.NAME, 'sep', 1831, 37, 1831, 40),
woosh.Token(woosh.OP, ',', 1831, 40, 1831, 41),
woosh.Token(woosh.STRING, '"/"', 1831, 42, 1831, 45),
woosh.Token(woosh.OP, ')', 1831, 45, 1831, 46),
woosh.Token(woosh.NEWLINE, '\r\n', 1831, 46, 1832, 0),
woosh.Token(woosh.NAME, 'arcname', 1832, 8, 1832, 15),
woosh.Token(woosh.OP, '=', 1832, 16, 1832, 17),
woosh.Token(woosh.NAME, 'arcname', 1832, 18, 1832, 25),
woosh.Token(woosh.OP, '.', 1832, 25, 1832, 26),
woosh.Token(woosh.NAME, 'lstrip', 1832, 26, 1832, 32),
woosh.Token(woosh.OP, '(', 1832, 32, 1832, 33),
woosh.Token(woosh.STRING, '"/"', 1832, 33, 1832, 36),
woosh.Token(woosh.OP, ')', 1832, 36, 1832, 37),
woosh.Token(woosh.NEWLINE, '\r\n', 1832, 37, 1833, 0),
woosh.Token(woosh.COMMENT, '# Now, fill the TarInfo object with', 1834, 8, 1834, 43),
woosh.Token(woosh.COMMENT, '# information specific for the file.', 1835, 8, 1835, 44),
woosh.Token(woosh.NAME, 'tarinfo', 1836, 8, 1836, 15),
woosh.Token(woosh.OP, '=', 1836, 16, 1836, 17),
woosh.Token(woosh.NAME, 'self', 1836, 18, 1836, 22),
woosh.Token(woosh.OP, '.', 1836, 22, 1836, 23),
woosh.Token(woosh.NAME, 'tarinfo', 1836, 23, 1836, 30),
woosh.Token(woosh.OP, '(', 1836, 30, 1836, 31),
woosh.Token(woosh.OP, ')', 1836, 31, 1836, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 1836, 32, 1837, 0),
woosh.Token(woosh.NAME, 'tarinfo', 1837, 8, 1837, 15),
woosh.Token(woosh.OP, '.', 1837, 15, 1837, 16),
woosh.Token(woosh.NAME, 'tarfile', 1837, 16, 1837, 23),
woosh.Token(woosh.OP, '=', 1837, 24, 1837, 25),
woosh.Token(woosh.NAME, 'self', 1837, 26, 1837, 30),
woosh.Token(woosh.COMMENT, '# Not needed', 1837, 32, 1837, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 1837, 44, 1838, 0),
woosh.Token(woosh.COMMENT, '# Use os.stat or os.lstat, depending on if symlinks shall be resolved.', 1839, 8, 1839, 78),
woosh.Token(woosh.NAME, 'if', 1840, 8, 1840, 10),
woosh.Token(woosh.NAME, 'fileobj', 1840, 11, 1840, 18),
woosh.Token(woosh.NAME, 'is', 1840, 19, 1840, 21),
woosh.Token(woosh.NAME, 'None', 1840, 22, 1840, 26),
woosh.Token(woosh.OP, ':', 1840, 26, 1840, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 1840, 27, 1841, 0),
woosh.Token(woosh.INDENT, ' ', 1841, 0, 1841, 12),
woosh.Token(woosh.NAME, 'if', 1841, 12, 1841, 14),
woosh.Token(woosh.NAME, 'not', 1841, 15, 1841, 18),
woosh.Token(woosh.NAME, 'self', 1841, 19, 1841, 23),
woosh.Token(woosh.OP, '.', 1841, 23, 1841, 24),
woosh.Token(woosh.NAME, 'dereference', 1841, 24, 1841, 35),
woosh.Token(woosh.OP, ':', 1841, 35, 1841, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 1841, 36, 1842, 0),
woosh.Token(woosh.INDENT, ' ', 1842, 0, 1842, 16),
woosh.Token(woosh.NAME, 'statres', 1842, 16, 1842, 23),
woosh.Token(woosh.OP, '=', 1842, 24, 1842, 25),
woosh.Token(woosh.NAME, 'os', 1842, 26, 1842, 28),
woosh.Token(woosh.OP, '.', 1842, 28, 1842, 29),
woosh.Token(woosh.NAME, 'lstat', 1842, 29, 1842, 34),
woosh.Token(woosh.OP, '(', 1842, 34, 1842, 35),
woosh.Token(woosh.NAME, 'name', 1842, 35, 1842, 39),
woosh.Token(woosh.OP, ')', 1842, 39, 1842, 40),
woosh.Token(woosh.NEWLINE, '\r\n', 1842, 40, 1843, 0),
woosh.Token(woosh.DEDENT, ' ', 1843, 0, 1843, 12),
woosh.Token(woosh.NAME, 'else', 1843, 12, 1843, 16),
woosh.Token(woosh.OP, ':', 1843, 16, 1843, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 1843, 17, 1844, 0),
woosh.Token(woosh.INDENT, ' ', 1844, 0, 1844, 16),
woosh.Token(woosh.NAME, 'statres', 1844, 16, 1844, 23),
woosh.Token(woosh.OP, '=', 1844, 24, 1844, 25),
woosh.Token(woosh.NAME, 'os', 1844, 26, 1844, 28),
woosh.Token(woosh.OP, '.', 1844, 28, 1844, 29),
woosh.Token(woosh.NAME, 'stat', 1844, 29, 1844, 33),
woosh.Token(woosh.OP, '(', 1844, 33, 1844, 34),
woosh.Token(woosh.NAME, 'name', 1844, 34, 1844, 38),
woosh.Token(woosh.OP, ')', 1844, 38, 1844, 39),
woosh.Token(woosh.NEWLINE, '\r\n', 1844, 39, 1845, 0),
woosh.Token(woosh.DEDENT, ' ', 1845, 0, 1845, 8),
woosh.Token(woosh.DEDENT, '', 1845, 8, 1845, 8),
woosh.Token(woosh.NAME, 'else', 1845, 8, 1845, 12),
woosh.Token(woosh.OP, ':', 1845, 12, 1845, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 1845, 13, 1846, 0),
woosh.Token(woosh.INDENT, ' ', 1846, 0, 1846, 12),
woosh.Token(woosh.NAME, 'statres', 1846, 12, 1846, 19),
woosh.Token(woosh.OP, '=', 1846, 20, 1846, 21),
woosh.Token(woosh.NAME, 'os', 1846, 22, 1846, 24),
woosh.Token(woosh.OP, '.', 1846, 24, 1846, 25),
woosh.Token(woosh.NAME, 'fstat', 1846, 25, 1846, 30),
woosh.Token(woosh.OP, '(', 1846, 30, 1846, 31),
woosh.Token(woosh.NAME, 'fileobj', 1846, 31, 1846, 38),
woosh.Token(woosh.OP, '.', 1846, 38, 1846, 39),
woosh.Token(woosh.NAME, 'fileno', 1846, 39, 1846, 45),
woosh.Token(woosh.OP, '(', 1846, 45, 1846, 46),
woosh.Token(woosh.OP, ')', 1846, 46, 1846, 47),
woosh.Token(woosh.OP, ')', 1846, 47, 1846, 48),
woosh.Token(woosh.NEWLINE, '\r\n', 1846, 48, 1847, 0),
woosh.Token(woosh.DEDENT, ' ', 1847, 0, 1847, 8),
woosh.Token(woosh.NAME, 'linkname', 1847, 8, 1847, 16),
woosh.Token(woosh.OP, '=', 1847, 17, 1847, 18),
woosh.Token(woosh.STRING, '""', 1847, 19, 1847, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 1847, 21, 1848, 0),
woosh.Token(woosh.NAME, 'stmd', 1849, 8, 1849, 12),
woosh.Token(woosh.OP, '=', 1849, 13, 1849, 14),
woosh.Token(woosh.NAME, 'statres', 1849, 15, 1849, 22),
woosh.Token(woosh.OP, '.', 1849, 22, 1849, 23),
woosh.Token(woosh.NAME, 'st_mode', 1849, 23, 1849, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 1849, 30, 1850, 0),
woosh.Token(woosh.NAME, 'if', 1850, 8, 1850, 10),
woosh.Token(woosh.NAME, 'stat', 1850, 11, 1850, 15),
woosh.Token(woosh.OP, '.', 1850, 15, 1850, 16),
woosh.Token(woosh.NAME, 'S_ISREG', 1850, 16, 1850, 23),
woosh.Token(woosh.OP, '(', 1850, 23, 1850, 24),
woosh.Token(woosh.NAME, 'stmd', 1850, 24, 1850, 28),
woosh.Token(woosh.OP, ')', 1850, 28, 1850, 29),
woosh.Token(woosh.OP, ':', 1850, 29, 1850, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 1850, 30, 1851, 0),
woosh.Token(woosh.INDENT, ' ', 1851, 0, 1851, 12),
woosh.Token(woosh.NAME, 'inode', 1851, 12, 1851, 17),
woosh.Token(woosh.OP, '=', 1851, 18, 1851, 19),
woosh.Token(woosh.OP, '(', 1851, 20, 1851, 21),
woosh.Token(woosh.NAME, 'statres', 1851, 21, 1851, 28),
woosh.Token(woosh.OP, '.', 1851, 28, 1851, 29),
woosh.Token(woosh.NAME, 'st_ino', 1851, 29, 1851, 35),
woosh.Token(woosh.OP, ',', 1851, 35, 1851, 36),
woosh.Token(woosh.NAME, 'statres', 1851, 37, 1851, 44),
woosh.Token(woosh.OP, '.', 1851, 44, 1851, 45),
woosh.Token(woosh.NAME, 'st_dev', 1851, 45, 1851, 51),
woosh.Token(woosh.OP, ')', 1851, 51, 1851, 52),
woosh.Token(woosh.NEWLINE, '\r\n', 1851, 52, 1852, 0),
woosh.Token(woosh.NAME, 'if', 1852, 12, 1852, 14),
woosh.Token(woosh.NAME, 'not', 1852, 15, 1852, 18),
woosh.Token(woosh.NAME, 'self', 1852, 19, 1852, 23),
woosh.Token(woosh.OP, '.', 1852, 23, 1852, 24),
woosh.Token(woosh.NAME, 'dereference', 1852, 24, 1852, 35),
woosh.Token(woosh.NAME, 'and', 1852, 36, 1852, 39),
woosh.Token(woosh.NAME, 'statres', 1852, 40, 1852, 47),
woosh.Token(woosh.OP, '.', 1852, 47, 1852, 48),
woosh.Token(woosh.NAME, 'st_nlink', 1852, 48, 1852, 56),
woosh.Token(woosh.OP, '>', 1852, 57, 1852, 58),
woosh.Token(woosh.NUMBER, '1', 1852, 59, 1852, 60),
woosh.Token(woosh.NAME, 'and', 1852, 61, 1852, 64),
woosh.Token(woosh.NAME, 'inode', 1853, 20, 1853, 25),
woosh.Token(woosh.NAME, 'in', 1853, 26, 1853, 28),
woosh.Token(woosh.NAME, 'self', 1853, 29, 1853, 33),
woosh.Token(woosh.OP, '.', 1853, 33, 1853, 34),
woosh.Token(woosh.NAME, 'inodes', 1853, 34, 1853, 40),
woosh.Token(woosh.NAME, 'and', 1853, 41, 1853, 44),
woosh.Token(woosh.NAME, 'arcname', 1853, 45, 1853, 52),
woosh.Token(woosh.OP, '!=', 1853, 53, 1853, 55),
woosh.Token(woosh.NAME, 'self', 1853, 56, 1853, 60),
woosh.Token(woosh.OP, '.', 1853, 60, 1853, 61),
woosh.Token(woosh.NAME, 'inodes', 1853, 61, 1853, 67),
woosh.Token(woosh.OP, '[', 1853, 67, 1853, 68),
woosh.Token(woosh.NAME, 'inode', 1853, 68, 1853, 73),
woosh.Token(woosh.OP, ']', 1853, 73, 1853, 74),
woosh.Token(woosh.OP, ':', 1853, 74, 1853, 75),
woosh.Token(woosh.NEWLINE, '\r\n', 1853, 75, 1854, 0),
woosh.Token(woosh.COMMENT, '# Is it a hardlink to an already', 1854, 16, 1854, 48),
woosh.Token(woosh.COMMENT, '# archived file?', 1855, 16, 1855, 32),
woosh.Token(woosh.INDENT, ' ', 1856, 0, 1856, 16),
woosh.Token(woosh.NAME, 'type', 1856, 16, 1856, 20),
woosh.Token(woosh.OP, '=', 1856, 21, 1856, 22),
woosh.Token(woosh.NAME, 'LNKTYPE', 1856, 23, 1856, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 1856, 30, 1857, 0),
woosh.Token(woosh.NAME, 'linkname', 1857, 16, 1857, 24),
woosh.Token(woosh.OP, '=', 1857, 25, 1857, 26),
woosh.Token(woosh.NAME, 'self', 1857, 27, 1857, 31),
woosh.Token(woosh.OP, '.', 1857, 31, 1857, 32),
woosh.Token(woosh.NAME, 'inodes', 1857, 32, 1857, 38),
woosh.Token(woosh.OP, '[', 1857, 38, 1857, 39),
woosh.Token(woosh.NAME, 'inode', 1857, 39, 1857, 44),
woosh.Token(woosh.OP, ']', 1857, 44, 1857, 45),
woosh.Token(woosh.NEWLINE, '\r\n', 1857, 45, 1858, 0),
woosh.Token(woosh.DEDENT, ' ', 1858, 0, 1858, 12),
woosh.Token(woosh.NAME, 'else', 1858, 12, 1858, 16),
woosh.Token(woosh.OP, ':', 1858, 16, 1858, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 1858, 17, 1859, 0),
woosh.Token(woosh.COMMENT, '# The inode is added only if its valid.', 1859, 16, 1859, 55),
woosh.Token(woosh.COMMENT, '# For win32 it is always 0.', 1860, 16, 1860, 43),
woosh.Token(woosh.INDENT, ' ', 1861, 0, 1861, 16),
woosh.Token(woosh.NAME, 'type', 1861, 16, 1861, 20),
woosh.Token(woosh.OP, '=', 1861, 21, 1861, 22),
woosh.Token(woosh.NAME, 'REGTYPE', 1861, 23, 1861, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 1861, 30, 1862, 0),
woosh.Token(woosh.NAME, 'if', 1862, 16, 1862, 18),
woosh.Token(woosh.NAME, 'inode', 1862, 19, 1862, 24),
woosh.Token(woosh.OP, '[', 1862, 24, 1862, 25),
woosh.Token(woosh.NUMBER, '0', 1862, 25, 1862, 26),
woosh.Token(woosh.OP, ']', 1862, 26, 1862, 27),
woosh.Token(woosh.OP, ':', 1862, 27, 1862, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 1862, 28, 1863, 0),
woosh.Token(woosh.INDENT, ' ', 1863, 0, 1863, 20),
woosh.Token(woosh.NAME, 'self', 1863, 20, 1863, 24),
woosh.Token(woosh.OP, '.', 1863, 24, 1863, 25),
woosh.Token(woosh.NAME, 'inodes', 1863, 25, 1863, 31),
woosh.Token(woosh.OP, '[', 1863, 31, 1863, 32),
woosh.Token(woosh.NAME, 'inode', 1863, 32, 1863, 37),
woosh.Token(woosh.OP, ']', 1863, 37, 1863, 38),
woosh.Token(woosh.OP, '=', 1863, 39, 1863, 40),
woosh.Token(woosh.NAME, 'arcname', 1863, 41, 1863, 48),
woosh.Token(woosh.NEWLINE, '\r\n', 1863, 48, 1864, 0),
woosh.Token(woosh.DEDENT, ' ', 1864, 0, 1864, 8),
woosh.Token(woosh.DEDENT, '', 1864, 8, 1864, 8),
woosh.Token(woosh.DEDENT, '', 1864, 8, 1864, 8),
woosh.Token(woosh.NAME, 'elif', 1864, 8, 1864, 12),
woosh.Token(woosh.NAME, 'stat', 1864, 13, 1864, 17),
woosh.Token(woosh.OP, '.', 1864, 17, 1864, 18),
woosh.Token(woosh.NAME, 'S_ISDIR', 1864, 18, 1864, 25),
woosh.Token(woosh.OP, '(', 1864, 25, 1864, 26),
woosh.Token(woosh.NAME, 'stmd', 1864, 26, 1864, 30),
woosh.Token(woosh.OP, ')', 1864, 30, 1864, 31),
woosh.Token(woosh.OP, ':', 1864, 31, 1864, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 1864, 32, 1865, 0),
woosh.Token(woosh.INDENT, ' ', 1865, 0, 1865, 12),
woosh.Token(woosh.NAME, 'type', 1865, 12, 1865, 16),
woosh.Token(woosh.OP, '=', 1865, 17, 1865, 18),
woosh.Token(woosh.NAME, 'DIRTYPE', 1865, 19, 1865, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 1865, 26, 1866, 0),
woosh.Token(woosh.DEDENT, ' ', 1866, 0, 1866, 8),
woosh.Token(woosh.NAME, 'elif', 1866, 8, 1866, 12),
woosh.Token(woosh.NAME, 'stat', 1866, 13, 1866, 17),
woosh.Token(woosh.OP, '.', 1866, 17, 1866, 18),
woosh.Token(woosh.NAME, 'S_ISFIFO', 1866, 18, 1866, 26),
woosh.Token(woosh.OP, '(', 1866, 26, 1866, 27),
woosh.Token(woosh.NAME, 'stmd', 1866, 27, 1866, 31),
woosh.Token(woosh.OP, ')', 1866, 31, 1866, 32),
woosh.Token(woosh.OP, ':', 1866, 32, 1866, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 1866, 33, 1867, 0),
woosh.Token(woosh.INDENT, ' ', 1867, 0, 1867, 12),
woosh.Token(woosh.NAME, 'type', 1867, 12, 1867, 16),
woosh.Token(woosh.OP, '=', 1867, 17, 1867, 18),
woosh.Token(woosh.NAME, 'FIFOTYPE', 1867, 19, 1867, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 1867, 27, 1868, 0),
woosh.Token(woosh.DEDENT, ' ', 1868, 0, 1868, 8),
woosh.Token(woosh.NAME, 'elif', 1868, 8, 1868, 12),
woosh.Token(woosh.NAME, 'stat', 1868, 13, 1868, 17),
woosh.Token(woosh.OP, '.', 1868, 17, 1868, 18),
woosh.Token(woosh.NAME, 'S_ISLNK', 1868, 18, 1868, 25),
woosh.Token(woosh.OP, '(', 1868, 25, 1868, 26),
woosh.Token(woosh.NAME, 'stmd', 1868, 26, 1868, 30),
woosh.Token(woosh.OP, ')', 1868, 30, 1868, 31),
woosh.Token(woosh.OP, ':', 1868, 31, 1868, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 1868, 32, 1869, 0),
woosh.Token(woosh.INDENT, ' ', 1869, 0, 1869, 12),
woosh.Token(woosh.NAME, 'type', 1869, 12, 1869, 16),
woosh.Token(woosh.OP, '=', 1869, 17, 1869, 18),
woosh.Token(woosh.NAME, 'SYMTYPE', 1869, 19, 1869, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 1869, 26, 1870, 0),
woosh.Token(woosh.NAME, 'linkname', 1870, 12, 1870, 20),
woosh.Token(woosh.OP, '=', 1870, 21, 1870, 22),
woosh.Token(woosh.NAME, 'os', 1870, 23, 1870, 25),
woosh.Token(woosh.OP, '.', 1870, 25, 1870, 26),
woosh.Token(woosh.NAME, 'readlink', 1870, 26, 1870, 34),
woosh.Token(woosh.OP, '(', 1870, 34, 1870, 35),
woosh.Token(woosh.NAME, 'name', 1870, 35, 1870, 39),
woosh.Token(woosh.OP, ')', 1870, 39, 1870, 40),
woosh.Token(woosh.NEWLINE, '\r\n', 1870, 40, 1871, 0),
woosh.Token(woosh.DEDENT, ' ', 1871, 0, 1871, 8),
woosh.Token(woosh.NAME, 'elif', 1871, 8, 1871, 12),
woosh.Token(woosh.NAME, 'stat', 1871, 13, 1871, 17),
woosh.Token(woosh.OP, '.', 1871, 17, 1871, 18),
woosh.Token(woosh.NAME, 'S_ISCHR', 1871, 18, 1871, 25),
woosh.Token(woosh.OP, '(', 1871, 25, 1871, 26),
woosh.Token(woosh.NAME, 'stmd', 1871, 26, 1871, 30),
woosh.Token(woosh.OP, ')', 1871, 30, 1871, 31),
woosh.Token(woosh.OP, ':', 1871, 31, 1871, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 1871, 32, 1872, 0),
woosh.Token(woosh.INDENT, ' ', 1872, 0, 1872, 12),
woosh.Token(woosh.NAME, 'type', 1872, 12, 1872, 16),
woosh.Token(woosh.OP, '=', 1872, 17, 1872, 18),
woosh.Token(woosh.NAME, 'CHRTYPE', 1872, 19, 1872, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 1872, 26, 1873, 0),
woosh.Token(woosh.DEDENT, ' ', 1873, 0, 1873, 8),
woosh.Token(woosh.NAME, 'elif', 1873, 8, 1873, 12),
woosh.Token(woosh.NAME, 'stat', 1873, 13, 1873, 17),
woosh.Token(woosh.OP, '.', 1873, 17, 1873, 18),
woosh.Token(woosh.NAME, 'S_ISBLK', 1873, 18, 1873, 25),
woosh.Token(woosh.OP, '(', 1873, 25, 1873, 26),
woosh.Token(woosh.NAME, 'stmd', 1873, 26, 1873, 30),
woosh.Token(woosh.OP, ')', 1873, 30, 1873, 31),
woosh.Token(woosh.OP, ':', 1873, 31, 1873, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 1873, 32, 1874, 0),
woosh.Token(woosh.INDENT, ' ', 1874, 0, 1874, 12),
woosh.Token(woosh.NAME, 'type', 1874, 12, 1874, 16),
woosh.Token(woosh.OP, '=', 1874, 17, 1874, 18),
woosh.Token(woosh.NAME, 'BLKTYPE', 1874, 19, 1874, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 1874, 26, 1875, 0),
woosh.Token(woosh.DEDENT, ' ', 1875, 0, 1875, 8),
woosh.Token(woosh.NAME, 'else', 1875, 8, 1875, 12),
woosh.Token(woosh.OP, ':', 1875, 12, 1875, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 1875, 13, 1876, 0),
woosh.Token(woosh.INDENT, ' ', 1876, 0, 1876, 12),
woosh.Token(woosh.NAME, 'return', 1876, 12, 1876, 18),
woosh.Token(woosh.NAME, 'None', 1876, 19, 1876, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 1876, 23, 1877, 0),
woosh.Token(woosh.COMMENT, '# Fill the TarInfo object with all', 1878, 8, 1878, 42),
woosh.Token(woosh.COMMENT, '# information we can get.', 1879, 8, 1879, 33),
woosh.Token(woosh.DEDENT, ' ', 1880, 0, 1880, 8),
woosh.Token(woosh.NAME, 'tarinfo', 1880, 8, 1880, 15),
woosh.Token(woosh.OP, '.', 1880, 15, 1880, 16),
woosh.Token(woosh.NAME, 'name', 1880, 16, 1880, 20),
woosh.Token(woosh.OP, '=', 1880, 21, 1880, 22),
woosh.Token(woosh.NAME, 'arcname', 1880, 23, 1880, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 1880, 30, 1881, 0),
woosh.Token(woosh.NAME, 'tarinfo', 1881, 8, 1881, 15),
woosh.Token(woosh.OP, '.', 1881, 15, 1881, 16),
woosh.Token(woosh.NAME, 'mode', 1881, 16, 1881, 20),
woosh.Token(woosh.OP, '=', 1881, 21, 1881, 22),
woosh.Token(woosh.NAME, 'stmd', 1881, 23, 1881, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 1881, 27, 1882, 0),
woosh.Token(woosh.NAME, 'tarinfo', 1882, 8, 1882, 15),
woosh.Token(woosh.OP, '.', 1882, 15, 1882, 16),
woosh.Token(woosh.NAME, 'uid', 1882, 16, 1882, 19),
woosh.Token(woosh.OP, '=', 1882, 20, 1882, 21),
woosh.Token(woosh.NAME, 'statres', 1882, 22, 1882, 29),
woosh.Token(woosh.OP, '.', 1882, 29, 1882, 30),
woosh.Token(woosh.NAME, 'st_uid', 1882, 30, 1882, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 1882, 36, 1883, 0),
woosh.Token(woosh.NAME, 'tarinfo', 1883, 8, 1883, 15),
woosh.Token(woosh.OP, '.', 1883, 15, 1883, 16),
woosh.Token(woosh.NAME, 'gid', 1883, 16, 1883, 19),
woosh.Token(woosh.OP, '=', 1883, 20, 1883, 21),
woosh.Token(woosh.NAME, 'statres', 1883, 22, 1883, 29),
woosh.Token(woosh.OP, '.', 1883, 29, 1883, 30),
woosh.Token(woosh.NAME, 'st_gid', 1883, 30, 1883, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 1883, 36, 1884, 0),
woosh.Token(woosh.NAME, 'if', 1884, 8, 1884, 10),
woosh.Token(woosh.NAME, 'type', 1884, 11, 1884, 15),
woosh.Token(woosh.OP, '==', 1884, 16, 1884, 18),
woosh.Token(woosh.NAME, 'REGTYPE', 1884, 19, 1884, 26),
woosh.Token(woosh.OP, ':', 1884, 26, 1884, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 1884, 27, 1885, 0),
woosh.Token(woosh.INDENT, ' ', 1885, 0, 1885, 12),
woosh.Token(woosh.NAME, 'tarinfo', 1885, 12, 1885, 19),
woosh.Token(woosh.OP, '.', 1885, 19, 1885, 20),
woosh.Token(woosh.NAME, 'size', 1885, 20, 1885, 24),
woosh.Token(woosh.OP, '=', 1885, 25, 1885, 26),
woosh.Token(woosh.NAME, 'statres', 1885, 27, 1885, 34),
woosh.Token(woosh.OP, '.', 1885, 34, 1885, 35),
woosh.Token(woosh.NAME, 'st_size', 1885, 35, 1885, 42),
woosh.Token(woosh.NEWLINE, '\r\n', 1885, 42, 1886, 0),
woosh.Token(woosh.DEDENT, ' ', 1886, 0, 1886, 8),
woosh.Token(woosh.NAME, 'else', 1886, 8, 1886, 12),
woosh.Token(woosh.OP, ':', 1886, 12, 1886, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 1886, 13, 1887, 0),
woosh.Token(woosh.INDENT, ' ', 1887, 0, 1887, 12),
woosh.Token(woosh.NAME, 'tarinfo', 1887, 12, 1887, 19),
woosh.Token(woosh.OP, '.', 1887, 19, 1887, 20),
woosh.Token(woosh.NAME, 'size', 1887, 20, 1887, 24),
woosh.Token(woosh.OP, '=', 1887, 25, 1887, 26),
woosh.Token(woosh.NUMBER, '0', 1887, 27, 1887, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 1887, 28, 1888, 0),
woosh.Token(woosh.DEDENT, ' ', 1888, 0, 1888, 8),
woosh.Token(woosh.NAME, 'tarinfo', 1888, 8, 1888, 15),
woosh.Token(woosh.OP, '.', 1888, 15, 1888, 16),
woosh.Token(woosh.NAME, 'mtime', 1888, 16, 1888, 21),
woosh.Token(woosh.OP, '=', 1888, 22, 1888, 23),
woosh.Token(woosh.NAME, 'statres', 1888, 24, 1888, 31),
woosh.Token(woosh.OP, '.', 1888, 31, 1888, 32),
woosh.Token(woosh.NAME, 'st_mtime', 1888, 32, 1888, 40),
woosh.Token(woosh.NEWLINE, '\r\n', 1888, 40, 1889, 0),
woosh.Token(woosh.NAME, 'tarinfo', 1889, 8, 1889, 15),
woosh.Token(woosh.OP, '.', 1889, 15, 1889, 16),
woosh.Token(woosh.NAME, 'type', 1889, 16, 1889, 20),
woosh.Token(woosh.OP, '=', 1889, 21, 1889, 22),
woosh.Token(woosh.NAME, 'type', 1889, 23, 1889, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 1889, 27, 1890, 0),
woosh.Token(woosh.NAME, 'tarinfo', 1890, 8, 1890, 15),
woosh.Token(woosh.OP, '.', 1890, 15, 1890, 16),
woosh.Token(woosh.NAME, 'linkname', 1890, 16, 1890, 24),
woosh.Token(woosh.OP, '=', 1890, 25, 1890, 26),
woosh.Token(woosh.NAME, 'linkname', 1890, 27, 1890, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 1890, 35, 1891, 0),
woosh.Token(woosh.NAME, 'if', 1891, 8, 1891, 10),
woosh.Token(woosh.NAME, 'pwd', 1891, 11, 1891, 14),
woosh.Token(woosh.OP, ':', 1891, 14, 1891, 15),
woosh.Token(woosh.NEWLINE, '\r\n', 1891, 15, 1892, 0),
woosh.Token(woosh.INDENT, ' ', 1892, 0, 1892, 12),
woosh.Token(woosh.NAME, 'try', 1892, 12, 1892, 15),
woosh.Token(woosh.OP, ':', 1892, 15, 1892, 16),
woosh.Token(woosh.NEWLINE, '\r\n', 1892, 16, 1893, 0),
woosh.Token(woosh.INDENT, ' ', 1893, 0, 1893, 16),
woosh.Token(woosh.NAME, 'tarinfo', 1893, 16, 1893, 23),
woosh.Token(woosh.OP, '.', 1893, 23, 1893, 24),
woosh.Token(woosh.NAME, 'uname', 1893, 24, 1893, 29),
woosh.Token(woosh.OP, '=', 1893, 30, 1893, 31),
woosh.Token(woosh.NAME, 'pwd', 1893, 32, 1893, 35),
woosh.Token(woosh.OP, '.', 1893, 35, 1893, 36),
woosh.Token(woosh.NAME, 'getpwuid', 1893, 36, 1893, 44),
woosh.Token(woosh.OP, '(', 1893, 44, 1893, 45),
woosh.Token(woosh.NAME, 'tarinfo', 1893, 45, 1893, 52),
woosh.Token(woosh.OP, '.', 1893, 52, 1893, 53),
woosh.Token(woosh.NAME, 'uid', 1893, 53, 1893, 56),
woosh.Token(woosh.OP, ')', 1893, 56, 1893, 57),
woosh.Token(woosh.OP, '[', 1893, 57, 1893, 58),
woosh.Token(woosh.NUMBER, '0', 1893, 58, 1893, 59),
woosh.Token(woosh.OP, ']', 1893, 59, 1893, 60),
woosh.Token(woosh.NEWLINE, '\r\n', 1893, 60, 1894, 0),
woosh.Token(woosh.DEDENT, ' ', 1894, 0, 1894, 12),
woosh.Token(woosh.NAME, 'except', 1894, 12, 1894, 18),
woosh.Token(woosh.NAME, 'KeyError', 1894, 19, 1894, 27),
woosh.Token(woosh.OP, ':', 1894, 27, 1894, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 1894, 28, 1895, 0),
woosh.Token(woosh.INDENT, ' ', 1895, 0, 1895, 16),
woosh.Token(woosh.NAME, 'pass', 1895, 16, 1895, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 1895, 20, 1896, 0),
woosh.Token(woosh.DEDENT, ' ', 1896, 0, 1896, 8),
woosh.Token(woosh.DEDENT, '', 1896, 8, 1896, 8),
woosh.Token(woosh.NAME, 'if', 1896, 8, 1896, 10),
woosh.Token(woosh.NAME, 'grp', 1896, 11, 1896, 14),
woosh.Token(woosh.OP, ':', 1896, 14, 1896, 15),
woosh.Token(woosh.NEWLINE, '\r\n', 1896, 15, 1897, 0),
woosh.Token(woosh.INDENT, ' ', 1897, 0, 1897, 12),
woosh.Token(woosh.NAME, 'try', 1897, 12, 1897, 15),
woosh.Token(woosh.OP, ':', 1897, 15, 1897, 16),
woosh.Token(woosh.NEWLINE, '\r\n', 1897, 16, 1898, 0),
woosh.Token(woosh.INDENT, ' ', 1898, 0, 1898, 16),
woosh.Token(woosh.NAME, 'tarinfo', 1898, 16, 1898, 23),
woosh.Token(woosh.OP, '.', 1898, 23, 1898, 24),
woosh.Token(woosh.NAME, 'gname', 1898, 24, 1898, 29),
woosh.Token(woosh.OP, '=', 1898, 30, 1898, 31),
woosh.Token(woosh.NAME, 'grp', 1898, 32, 1898, 35),
woosh.Token(woosh.OP, '.', 1898, 35, 1898, 36),
woosh.Token(woosh.NAME, 'getgrgid', 1898, 36, 1898, 44),
woosh.Token(woosh.OP, '(', 1898, 44, 1898, 45),
woosh.Token(woosh.NAME, 'tarinfo', 1898, 45, 1898, 52),
woosh.Token(woosh.OP, '.', 1898, 52, 1898, 53),
woosh.Token(woosh.NAME, 'gid', 1898, 53, 1898, 56),
woosh.Token(woosh.OP, ')', 1898, 56, 1898, 57),
woosh.Token(woosh.OP, '[', 1898, 57, 1898, 58),
woosh.Token(woosh.NUMBER, '0', 1898, 58, 1898, 59),
woosh.Token(woosh.OP, ']', 1898, 59, 1898, 60),
woosh.Token(woosh.NEWLINE, '\r\n', 1898, 60, 1899, 0),
woosh.Token(woosh.DEDENT, ' ', 1899, 0, 1899, 12),
woosh.Token(woosh.NAME, 'except', 1899, 12, 1899, 18),
woosh.Token(woosh.NAME, 'KeyError', 1899, 19, 1899, 27),
woosh.Token(woosh.OP, ':', 1899, 27, 1899, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 1899, 28, 1900, 0),
woosh.Token(woosh.INDENT, ' ', 1900, 0, 1900, 16),
woosh.Token(woosh.NAME, 'pass', 1900, 16, 1900, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 1900, 20, 1901, 0),
woosh.Token(woosh.DEDENT, ' ', 1902, 0, 1902, 8),
woosh.Token(woosh.DEDENT, '', 1902, 8, 1902, 8),
woosh.Token(woosh.NAME, 'if', 1902, 8, 1902, 10),
woosh.Token(woosh.NAME, 'type', 1902, 11, 1902, 15),
woosh.Token(woosh.NAME, 'in', 1902, 16, 1902, 18),
woosh.Token(woosh.OP, '(', 1902, 19, 1902, 20),
woosh.Token(woosh.NAME, 'CHRTYPE', 1902, 20, 1902, 27),
woosh.Token(woosh.OP, ',', 1902, 27, 1902, 28),
woosh.Token(woosh.NAME, 'BLKTYPE', 1902, 29, 1902, 36),
woosh.Token(woosh.OP, ')', 1902, 36, 1902, 37),
woosh.Token(woosh.OP, ':', 1902, 37, 1902, 38),
woosh.Token(woosh.NEWLINE, '\r\n', 1902, 38, 1903, 0),
woosh.Token(woosh.INDENT, ' ', 1903, 0, 1903, 12),
woosh.Token(woosh.NAME, 'if', 1903, 12, 1903, 14),
woosh.Token(woosh.NAME, 'hasattr', 1903, 15, 1903, 22),
woosh.Token(woosh.OP, '(', 1903, 22, 1903, 23),
woosh.Token(woosh.NAME, 'os', 1903, 23, 1903, 25),
woosh.Token(woosh.OP, ',', 1903, 25, 1903, 26),
woosh.Token(woosh.STRING, '"major"', 1903, 27, 1903, 34),
woosh.Token(woosh.OP, ')', 1903, 34, 1903, 35),
woosh.Token(woosh.NAME, 'and', 1903, 36, 1903, 39),
woosh.Token(woosh.NAME, 'hasattr', 1903, 40, 1903, 47),
woosh.Token(woosh.OP, '(', 1903, 47, 1903, 48),
woosh.Token(woosh.NAME, 'os', 1903, 48, 1903, 50),
woosh.Token(woosh.OP, ',', 1903, 50, 1903, 51),
woosh.Token(woosh.STRING, '"minor"', 1903, 52, 1903, 59),
woosh.Token(woosh.OP, ')', 1903, 59, 1903, 60),
woosh.Token(woosh.OP, ':', 1903, 60, 1903, 61),
woosh.Token(woosh.NEWLINE, '\r\n', 1903, 61, 1904, 0),
woosh.Token(woosh.INDENT, ' ', 1904, 0, 1904, 16),
woosh.Token(woosh.NAME, 'tarinfo', 1904, 16, 1904, 23),
woosh.Token(woosh.OP, '.', 1904, 23, 1904, 24),
woosh.Token(woosh.NAME, 'devmajor', 1904, 24, 1904, 32),
woosh.Token(woosh.OP, '=', 1904, 33, 1904, 34),
woosh.Token(woosh.NAME, 'os', 1904, 35, 1904, 37),
woosh.Token(woosh.OP, '.', 1904, 37, 1904, 38),
woosh.Token(woosh.NAME, 'major', 1904, 38, 1904, 43),
woosh.Token(woosh.OP, '(', 1904, 43, 1904, 44),
woosh.Token(woosh.NAME, 'statres', 1904, 44, 1904, 51),
woosh.Token(woosh.OP, '.', 1904, 51, 1904, 52),
woosh.Token(woosh.NAME, 'st_rdev', 1904, 52, 1904, 59),
woosh.Token(woosh.OP, ')', 1904, 59, 1904, 60),
woosh.Token(woosh.NEWLINE, '\r\n', 1904, 60, 1905, 0),
woosh.Token(woosh.NAME, 'tarinfo', 1905, 16, 1905, 23),
woosh.Token(woosh.OP, '.', 1905, 23, 1905, 24),
woosh.Token(woosh.NAME, 'devminor', 1905, 24, 1905, 32),
woosh.Token(woosh.OP, '=', 1905, 33, 1905, 34),
woosh.Token(woosh.NAME, 'os', 1905, 35, 1905, 37),
woosh.Token(woosh.OP, '.', 1905, 37, 1905, 38),
woosh.Token(woosh.NAME, 'minor', 1905, 38, 1905, 43),
woosh.Token(woosh.OP, '(', 1905, 43, 1905, 44),
woosh.Token(woosh.NAME, 'statres', 1905, 44, 1905, 51),
woosh.Token(woosh.OP, '.', 1905, 51, 1905, 52),
woosh.Token(woosh.NAME, 'st_rdev', 1905, 52, 1905, 59),
woosh.Token(woosh.OP, ')', 1905, 59, 1905, 60),
woosh.Token(woosh.NEWLINE, '\r\n', 1905, 60, 1906, 0),
woosh.Token(woosh.DEDENT, ' ', 1906, 0, 1906, 8),
woosh.Token(woosh.DEDENT, '', 1906, 8, 1906, 8),
woosh.Token(woosh.NAME, 'return', 1906, 8, 1906, 14),
woosh.Token(woosh.NAME, 'tarinfo', 1906, 15, 1906, 22),
woosh.Token(woosh.NEWLINE, '\r\n', 1906, 22, 1907, 0),
woosh.Token(woosh.DEDENT, ' ', 1908, 0, 1908, 4),
woosh.Token(woosh.NAME, 'def', 1908, 4, 1908, 7),
woosh.Token(woosh.NAME, 'list', 1908, 8, 1908, 12),
woosh.Token(woosh.OP, '(', 1908, 12, 1908, 13),
woosh.Token(woosh.NAME, 'self', 1908, 13, 1908, 17),
woosh.Token(woosh.OP, ',', 1908, 17, 1908, 18),
woosh.Token(woosh.NAME, 'verbose', 1908, 19, 1908, 26),
woosh.Token(woosh.OP, '=', 1908, 26, 1908, 27),
woosh.Token(woosh.NAME, 'True', 1908, 27, 1908, 31),
woosh.Token(woosh.OP, ',', 1908, 31, 1908, 32),
woosh.Token(woosh.OP, '*', 1908, 33, 1908, 34),
woosh.Token(woosh.OP, ',', 1908, 34, 1908, 35),
woosh.Token(woosh.NAME, 'members', 1908, 36, 1908, 43),
woosh.Token(woosh.OP, '=', 1908, 43, 1908, 44),
woosh.Token(woosh.NAME, 'None', 1908, 44, 1908, 48),
woosh.Token(woosh.OP, ')', 1908, 48, 1908, 49),
woosh.Token(woosh.OP, ':', 1908, 49, 1908, 50),
woosh.Token(woosh.NEWLINE, '\r\n', 1908, 50, 1909, 0),
woosh.Token(woosh.INDENT, ' ', 1909, 0, 1909, 8),
woosh.Token(woosh.STRING, '"""Print a table of contents to sys.stdout. If `verbose\' is False, only\r\n the names of the members are printed. If it is True, an `ls -l\'-like\r\n output is produced. `members\' is optional and must be a subset of the\r\n list returned by getmembers().\r\n """', 1909, 8, 1913, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 1913, 11, 1914, 0),
woosh.Token(woosh.NAME, 'self', 1914, 8, 1914, 12),
woosh.Token(woosh.OP, '.', 1914, 12, 1914, 13),
woosh.Token(woosh.NAME, '_check', 1914, 13, 1914, 19),
woosh.Token(woosh.OP, '(', 1914, 19, 1914, 20),
woosh.Token(woosh.OP, ')', 1914, 20, 1914, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 1914, 21, 1915, 0),
woosh.Token(woosh.NAME, 'if', 1916, 8, 1916, 10),
woosh.Token(woosh.NAME, 'members', 1916, 11, 1916, 18),
woosh.Token(woosh.NAME, 'is', 1916, 19, 1916, 21),
woosh.Token(woosh.NAME, 'None', 1916, 22, 1916, 26),
woosh.Token(woosh.OP, ':', 1916, 26, 1916, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 1916, 27, 1917, 0),
woosh.Token(woosh.INDENT, ' ', 1917, 0, 1917, 12),
woosh.Token(woosh.NAME, 'members', 1917, 12, 1917, 19),
woosh.Token(woosh.OP, '=', 1917, 20, 1917, 21),
woosh.Token(woosh.NAME, 'self', 1917, 22, 1917, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 1917, 26, 1918, 0),
woosh.Token(woosh.DEDENT, ' ', 1918, 0, 1918, 8),
woosh.Token(woosh.NAME, 'for', 1918, 8, 1918, 11),
woosh.Token(woosh.NAME, 'tarinfo', 1918, 12, 1918, 19),
woosh.Token(woosh.NAME, 'in', 1918, 20, 1918, 22),
woosh.Token(woosh.NAME, 'members', 1918, 23, 1918, 30),
woosh.Token(woosh.OP, ':', 1918, 30, 1918, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 1918, 31, 1919, 0),
woosh.Token(woosh.INDENT, ' ', 1919, 0, 1919, 12),
woosh.Token(woosh.NAME, 'if', 1919, 12, 1919, 14),
woosh.Token(woosh.NAME, 'verbose', 1919, 15, 1919, 22),
woosh.Token(woosh.OP, ':', 1919, 22, 1919, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 1919, 23, 1920, 0),
woosh.Token(woosh.INDENT, ' ', 1920, 0, 1920, 16),
woosh.Token(woosh.NAME, '_safe_print', 1920, 16, 1920, 27),
woosh.Token(woosh.OP, '(', 1920, 27, 1920, 28),
woosh.Token(woosh.NAME, 'stat', 1920, 28, 1920, 32),
woosh.Token(woosh.OP, '.', 1920, 32, 1920, 33),
woosh.Token(woosh.NAME, 'filemode', 1920, 33, 1920, 41),
woosh.Token(woosh.OP, '(', 1920, 41, 1920, 42),
woosh.Token(woosh.NAME, 'tarinfo', 1920, 42, 1920, 49),
woosh.Token(woosh.OP, '.', 1920, 49, 1920, 50),
woosh.Token(woosh.NAME, 'mode', 1920, 50, 1920, 54),
woosh.Token(woosh.OP, ')', 1920, 54, 1920, 55),
woosh.Token(woosh.OP, ')', 1920, 55, 1920, 56),
woosh.Token(woosh.NEWLINE, '\r\n', 1920, 56, 1921, 0),
woosh.Token(woosh.NAME, '_safe_print', 1921, 16, 1921, 27),
woosh.Token(woosh.OP, '(', 1921, 27, 1921, 28),
woosh.Token(woosh.STRING, '"%s/%s"', 1921, 28, 1921, 35),
woosh.Token(woosh.OP, '%', 1921, 36, 1921, 37),
woosh.Token(woosh.OP, '(', 1921, 38, 1921, 39),
woosh.Token(woosh.NAME, 'tarinfo', 1921, 39, 1921, 46),
woosh.Token(woosh.OP, '.', 1921, 46, 1921, 47),
woosh.Token(woosh.NAME, 'uname', 1921, 47, 1921, 52),
woosh.Token(woosh.NAME, 'or', 1921, 53, 1921, 55),
woosh.Token(woosh.NAME, 'tarinfo', 1921, 56, 1921, 63),
woosh.Token(woosh.OP, '.', 1921, 63, 1921, 64),
woosh.Token(woosh.NAME, 'uid', 1921, 64, 1921, 67),
woosh.Token(woosh.OP, ',', 1921, 67, 1921, 68),
woosh.Token(woosh.NAME, 'tarinfo', 1922, 39, 1922, 46),
woosh.Token(woosh.OP, '.', 1922, 46, 1922, 47),
woosh.Token(woosh.NAME, 'gname', 1922, 47, 1922, 52),
woosh.Token(woosh.NAME, 'or', 1922, 53, 1922, 55),
woosh.Token(woosh.NAME, 'tarinfo', 1922, 56, 1922, 63),
woosh.Token(woosh.OP, '.', 1922, 63, 1922, 64),
woosh.Token(woosh.NAME, 'gid', 1922, 64, 1922, 67),
woosh.Token(woosh.OP, ')', 1922, 67, 1922, 68),
woosh.Token(woosh.OP, ')', 1922, 68, 1922, 69),
woosh.Token(woosh.NEWLINE, '\r\n', 1922, 69, 1923, 0),
woosh.Token(woosh.NAME, 'if', 1923, 16, 1923, 18),
woosh.Token(woosh.NAME, 'tarinfo', 1923, 19, 1923, 26),
woosh.Token(woosh.OP, '.', 1923, 26, 1923, 27),
woosh.Token(woosh.NAME, 'ischr', 1923, 27, 1923, 32),
woosh.Token(woosh.OP, '(', 1923, 32, 1923, 33),
woosh.Token(woosh.OP, ')', 1923, 33, 1923, 34),
woosh.Token(woosh.NAME, 'or', 1923, 35, 1923, 37),
woosh.Token(woosh.NAME, 'tarinfo', 1923, 38, 1923, 45),
woosh.Token(woosh.OP, '.', 1923, 45, 1923, 46),
woosh.Token(woosh.NAME, 'isblk', 1923, 46, 1923, 51),
woosh.Token(woosh.OP, '(', 1923, 51, 1923, 52),
woosh.Token(woosh.OP, ')', 1923, 52, 1923, 53),
woosh.Token(woosh.OP, ':', 1923, 53, 1923, 54),
woosh.Token(woosh.NEWLINE, '\r\n', 1923, 54, 1924, 0),
woosh.Token(woosh.INDENT, ' ', 1924, 0, 1924, 20),
woosh.Token(woosh.NAME, '_safe_print', 1924, 20, 1924, 31),
woosh.Token(woosh.OP, '(', 1924, 31, 1924, 32),
woosh.Token(woosh.STRING, '"%10s"', 1924, 32, 1924, 38),
woosh.Token(woosh.OP, '%', 1924, 39, 1924, 40),
woosh.Token(woosh.OP, '(', 1925, 28, 1925, 29),
woosh.Token(woosh.STRING, '"%d,%d"', 1925, 29, 1925, 36),
woosh.Token(woosh.OP, '%', 1925, 37, 1925, 38),
woosh.Token(woosh.OP, '(', 1925, 39, 1925, 40),
woosh.Token(woosh.NAME, 'tarinfo', 1925, 40, 1925, 47),
woosh.Token(woosh.OP, '.', 1925, 47, 1925, 48),
woosh.Token(woosh.NAME, 'devmajor', 1925, 48, 1925, 56),
woosh.Token(woosh.OP, ',', 1925, 56, 1925, 57),
woosh.Token(woosh.NAME, 'tarinfo', 1925, 58, 1925, 65),
woosh.Token(woosh.OP, '.', 1925, 65, 1925, 66),
woosh.Token(woosh.NAME, 'devminor', 1925, 66, 1925, 74),
woosh.Token(woosh.OP, ')', 1925, 74, 1925, 75),
woosh.Token(woosh.OP, ')', 1925, 75, 1925, 76),
woosh.Token(woosh.OP, ')', 1925, 76, 1925, 77),
woosh.Token(woosh.NEWLINE, '\r\n', 1925, 77, 1926, 0),
woosh.Token(woosh.DEDENT, ' ', 1926, 0, 1926, 16),
woosh.Token(woosh.NAME, 'else', 1926, 16, 1926, 20),
woosh.Token(woosh.OP, ':', 1926, 20, 1926, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 1926, 21, 1927, 0),
woosh.Token(woosh.INDENT, ' ', 1927, 0, 1927, 20),
woosh.Token(woosh.NAME, '_safe_print', 1927, 20, 1927, 31),
woosh.Token(woosh.OP, '(', 1927, 31, 1927, 32),
woosh.Token(woosh.STRING, '"%10d"', 1927, 32, 1927, 38),
woosh.Token(woosh.OP, '%', 1927, 39, 1927, 40),
woosh.Token(woosh.NAME, 'tarinfo', 1927, 41, 1927, 48),
woosh.Token(woosh.OP, '.', 1927, 48, 1927, 49),
woosh.Token(woosh.NAME, 'size', 1927, 49, 1927, 53),
woosh.Token(woosh.OP, ')', 1927, 53, 1927, 54),
woosh.Token(woosh.NEWLINE, '\r\n', 1927, 54, 1928, 0),
woosh.Token(woosh.DEDENT, ' ', 1928, 0, 1928, 16),
woosh.Token(woosh.NAME, '_safe_print', 1928, 16, 1928, 27),
woosh.Token(woosh.OP, '(', 1928, 27, 1928, 28),
woosh.Token(woosh.STRING, '"%d-%02d-%02d %02d:%02d:%02d"', 1928, 28, 1928, 57),
woosh.Token(woosh.OP, '%', 1929, 28, 1929, 29),
woosh.Token(woosh.NAME, 'time', 1929, 30, 1929, 34),
woosh.Token(woosh.OP, '.', 1929, 34, 1929, 35),
woosh.Token(woosh.NAME, 'localtime', 1929, 35, 1929, 44),
woosh.Token(woosh.OP, '(', 1929, 44, 1929, 45),
woosh.Token(woosh.NAME, 'tarinfo', 1929, 45, 1929, 52),
woosh.Token(woosh.OP, '.', 1929, 52, 1929, 53),
woosh.Token(woosh.NAME, 'mtime', 1929, 53, 1929, 58),
woosh.Token(woosh.OP, ')', 1929, 58, 1929, 59),
woosh.Token(woosh.OP, '[', 1929, 59, 1929, 60),
woosh.Token(woosh.OP, ':', 1929, 60, 1929, 61),
woosh.Token(woosh.NUMBER, '6', 1929, 61, 1929, 62),
woosh.Token(woosh.OP, ']', 1929, 62, 1929, 63),
woosh.Token(woosh.OP, ')', 1929, 63, 1929, 64),
woosh.Token(woosh.NEWLINE, '\r\n', 1929, 64, 1930, 0),
woosh.Token(woosh.DEDENT, ' ', 1931, 0, 1931, 12),
woosh.Token(woosh.NAME, '_safe_print', 1931, 12, 1931, 23),
woosh.Token(woosh.OP, '(', 1931, 23, 1931, 24),
woosh.Token(woosh.NAME, 'tarinfo', 1931, 24, 1931, 31),
woosh.Token(woosh.OP, '.', 1931, 31, 1931, 32),
woosh.Token(woosh.NAME, 'name', 1931, 32, 1931, 36),
woosh.Token(woosh.OP, '+', 1931, 37, 1931, 38),
woosh.Token(woosh.OP, '(', 1931, 39, 1931, 40),
woosh.Token(woosh.STRING, '"/"', 1931, 40, 1931, 43),
woosh.Token(woosh.NAME, 'if', 1931, 44, 1931, 46),
woosh.Token(woosh.NAME, 'tarinfo', 1931, 47, 1931, 54),
woosh.Token(woosh.OP, '.', 1931, 54, 1931, 55),
woosh.Token(woosh.NAME, 'isdir', 1931, 55, 1931, 60),
woosh.Token(woosh.OP, '(', 1931, 60, 1931, 61),
woosh.Token(woosh.OP, ')', 1931, 61, 1931, 62),
woosh.Token(woosh.NAME, 'else', 1931, 63, 1931, 67),
woosh.Token(woosh.STRING, '""', 1931, 68, 1931, 70),
woosh.Token(woosh.OP, ')', 1931, 70, 1931, 71),
woosh.Token(woosh.OP, ')', 1931, 71, 1931, 72),
woosh.Token(woosh.NEWLINE, '\r\n', 1931, 72, 1932, 0),
woosh.Token(woosh.NAME, 'if', 1933, 12, 1933, 14),
woosh.Token(woosh.NAME, 'verbose', 1933, 15, 1933, 22),
woosh.Token(woosh.OP, ':', 1933, 22, 1933, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 1933, 23, 1934, 0),
woosh.Token(woosh.INDENT, ' ', 1934, 0, 1934, 16),
woosh.Token(woosh.NAME, 'if', 1934, 16, 1934, 18),
woosh.Token(woosh.NAME, 'tarinfo', 1934, 19, 1934, 26),
woosh.Token(woosh.OP, '.', 1934, 26, 1934, 27),
woosh.Token(woosh.NAME, 'issym', 1934, 27, 1934, 32),
woosh.Token(woosh.OP, '(', 1934, 32, 1934, 33),
woosh.Token(woosh.OP, ')', 1934, 33, 1934, 34),
woosh.Token(woosh.OP, ':', 1934, 34, 1934, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 1934, 35, 1935, 0),
woosh.Token(woosh.INDENT, ' ', 1935, 0, 1935, 20),
woosh.Token(woosh.NAME, '_safe_print', 1935, 20, 1935, 31),
woosh.Token(woosh.OP, '(', 1935, 31, 1935, 32),
woosh.Token(woosh.STRING, '"-> "', 1935, 32, 1935, 37),
woosh.Token(woosh.OP, '+', 1935, 38, 1935, 39),
woosh.Token(woosh.NAME, 'tarinfo', 1935, 40, 1935, 47),
woosh.Token(woosh.OP, '.', 1935, 47, 1935, 48),
woosh.Token(woosh.NAME, 'linkname', 1935, 48, 1935, 56),
woosh.Token(woosh.OP, ')', 1935, 56, 1935, 57),
woosh.Token(woosh.NEWLINE, '\r\n', 1935, 57, 1936, 0),
woosh.Token(woosh.DEDENT, ' ', 1936, 0, 1936, 16),
woosh.Token(woosh.NAME, 'if', 1936, 16, 1936, 18),
woosh.Token(woosh.NAME, 'tarinfo', 1936, 19, 1936, 26),
woosh.Token(woosh.OP, '.', 1936, 26, 1936, 27),
woosh.Token(woosh.NAME, 'islnk', 1936, 27, 1936, 32),
woosh.Token(woosh.OP, '(', 1936, 32, 1936, 33),
woosh.Token(woosh.OP, ')', 1936, 33, 1936, 34),
woosh.Token(woosh.OP, ':', 1936, 34, 1936, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 1936, 35, 1937, 0),
woosh.Token(woosh.INDENT, ' ', 1937, 0, 1937, 20),
woosh.Token(woosh.NAME, '_safe_print', 1937, 20, 1937, 31),
woosh.Token(woosh.OP, '(', 1937, 31, 1937, 32),
woosh.Token(woosh.STRING, '"link to "', 1937, 32, 1937, 42),
woosh.Token(woosh.OP, '+', 1937, 43, 1937, 44),
woosh.Token(woosh.NAME, 'tarinfo', 1937, 45, 1937, 52),
woosh.Token(woosh.OP, '.', 1937, 52, 1937, 53),
woosh.Token(woosh.NAME, 'linkname', 1937, 53, 1937, 61),
woosh.Token(woosh.OP, ')', 1937, 61, 1937, 62),
woosh.Token(woosh.NEWLINE, '\r\n', 1937, 62, 1938, 0),
woosh.Token(woosh.DEDENT, ' ', 1938, 0, 1938, 12),
woosh.Token(woosh.DEDENT, '', 1938, 12, 1938, 12),
woosh.Token(woosh.NAME, 'print', 1938, 12, 1938, 17),
woosh.Token(woosh.OP, '(', 1938, 17, 1938, 18),
woosh.Token(woosh.OP, ')', 1938, 18, 1938, 19),
woosh.Token(woosh.NEWLINE, '\r\n', 1938, 19, 1939, 0),
woosh.Token(woosh.DEDENT, ' ', 1940, 0, 1940, 4),
woosh.Token(woosh.DEDENT, '', 1940, 4, 1940, 4),
woosh.Token(woosh.NAME, 'def', 1940, 4, 1940, 7),
woosh.Token(woosh.NAME, 'add', 1940, 8, 1940, 11),
woosh.Token(woosh.OP, '(', 1940, 11, 1940, 12),
woosh.Token(woosh.NAME, 'self', 1940, 12, 1940, 16),
woosh.Token(woosh.OP, ',', 1940, 16, 1940, 17),
woosh.Token(woosh.NAME, 'name', 1940, 18, 1940, 22),
woosh.Token(woosh.OP, ',', 1940, 22, 1940, 23),
woosh.Token(woosh.NAME, 'arcname', 1940, 24, 1940, 31),
woosh.Token(woosh.OP, '=', 1940, 31, 1940, 32),
woosh.Token(woosh.NAME, 'None', 1940, 32, 1940, 36),
woosh.Token(woosh.OP, ',', 1940, 36, 1940, 37),
woosh.Token(woosh.NAME, 'recursive', 1940, 38, 1940, 47),
woosh.Token(woosh.OP, '=', 1940, 47, 1940, 48),
woosh.Token(woosh.NAME, 'True', 1940, 48, 1940, 52),
woosh.Token(woosh.OP, ',', 1940, 52, 1940, 53),
woosh.Token(woosh.OP, '*', 1940, 54, 1940, 55),
woosh.Token(woosh.OP, ',', 1940, 55, 1940, 56),
woosh.Token(woosh.NAME, 'filter', 1940, 57, 1940, 63),
woosh.Token(woosh.OP, '=', 1940, 63, 1940, 64),
woosh.Token(woosh.NAME, 'None', 1940, 64, 1940, 68),
woosh.Token(woosh.OP, ')', 1940, 68, 1940, 69),
woosh.Token(woosh.OP, ':', 1940, 69, 1940, 70),
woosh.Token(woosh.NEWLINE, '\r\n', 1940, 70, 1941, 0),
woosh.Token(woosh.INDENT, ' ', 1941, 0, 1941, 8),
woosh.Token(woosh.STRING, '"""Add the file `name\' to the archive. `name\' may be any type of file\r\n (directory, fifo, symbolic link, etc.). If given, `arcname\'\r\n specifies an alternative name for the file in the archive.\r\n Directories are added recursively by default. This can be avoided by\r\n setting `recursive\' to False. `filter\' is a function\r\n that expects a TarInfo object argument and returns the changed\r\n TarInfo object, if it returns None the TarInfo object will be\r\n excluded from the archive.\r\n """', 1941, 8, 1949, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 1949, 11, 1950, 0),
woosh.Token(woosh.NAME, 'self', 1950, 8, 1950, 12),
woosh.Token(woosh.OP, '.', 1950, 12, 1950, 13),
woosh.Token(woosh.NAME, '_check', 1950, 13, 1950, 19),
woosh.Token(woosh.OP, '(', 1950, 19, 1950, 20),
woosh.Token(woosh.STRING, '"awx"', 1950, 20, 1950, 25),
woosh.Token(woosh.OP, ')', 1950, 25, 1950, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 1950, 26, 1951, 0),
woosh.Token(woosh.NAME, 'if', 1952, 8, 1952, 10),
woosh.Token(woosh.NAME, 'arcname', 1952, 11, 1952, 18),
woosh.Token(woosh.NAME, 'is', 1952, 19, 1952, 21),
woosh.Token(woosh.NAME, 'None', 1952, 22, 1952, 26),
woosh.Token(woosh.OP, ':', 1952, 26, 1952, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 1952, 27, 1953, 0),
woosh.Token(woosh.INDENT, ' ', 1953, 0, 1953, 12),
woosh.Token(woosh.NAME, 'arcname', 1953, 12, 1953, 19),
woosh.Token(woosh.OP, '=', 1953, 20, 1953, 21),
woosh.Token(woosh.NAME, 'name', 1953, 22, 1953, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 1953, 26, 1954, 0),
woosh.Token(woosh.COMMENT, '# Skip if somebody tries to archive the archive...', 1955, 8, 1955, 58),
woosh.Token(woosh.DEDENT, ' ', 1956, 0, 1956, 8),
woosh.Token(woosh.NAME, 'if', 1956, 8, 1956, 10),
woosh.Token(woosh.NAME, 'self', 1956, 11, 1956, 15),
woosh.Token(woosh.OP, '.', 1956, 15, 1956, 16),
woosh.Token(woosh.NAME, 'name', 1956, 16, 1956, 20),
woosh.Token(woosh.NAME, 'is', 1956, 21, 1956, 23),
woosh.Token(woosh.NAME, 'not', 1956, 24, 1956, 27),
woosh.Token(woosh.NAME, 'None', 1956, 28, 1956, 32),
woosh.Token(woosh.NAME, 'and', 1956, 33, 1956, 36),
woosh.Token(woosh.NAME, 'os', 1956, 37, 1956, 39),
woosh.Token(woosh.OP, '.', 1956, 39, 1956, 40),
woosh.Token(woosh.NAME, 'path', 1956, 40, 1956, 44),
woosh.Token(woosh.OP, '.', 1956, 44, 1956, 45),
woosh.Token(woosh.NAME, 'abspath', 1956, 45, 1956, 52),
woosh.Token(woosh.OP, '(', 1956, 52, 1956, 53),
woosh.Token(woosh.NAME, 'name', 1956, 53, 1956, 57),
woosh.Token(woosh.OP, ')', 1956, 57, 1956, 58),
woosh.Token(woosh.OP, '==', 1956, 59, 1956, 61),
woosh.Token(woosh.NAME, 'self', 1956, 62, 1956, 66),
woosh.Token(woosh.OP, '.', 1956, 66, 1956, 67),
woosh.Token(woosh.NAME, 'name', 1956, 67, 1956, 71),
woosh.Token(woosh.OP, ':', 1956, 71, 1956, 72),
woosh.Token(woosh.NEWLINE, '\r\n', 1956, 72, 1957, 0),
woosh.Token(woosh.INDENT, ' ', 1957, 0, 1957, 12),
woosh.Token(woosh.NAME, 'self', 1957, 12, 1957, 16),
woosh.Token(woosh.OP, '.', 1957, 16, 1957, 17),
woosh.Token(woosh.NAME, '_dbg', 1957, 17, 1957, 21),
woosh.Token(woosh.OP, '(', 1957, 21, 1957, 22),
woosh.Token(woosh.NUMBER, '2', 1957, 22, 1957, 23),
woosh.Token(woosh.OP, ',', 1957, 23, 1957, 24),
woosh.Token(woosh.STRING, '"tarfile: Skipped %r"', 1957, 25, 1957, 46),
woosh.Token(woosh.OP, '%', 1957, 47, 1957, 48),
woosh.Token(woosh.NAME, 'name', 1957, 49, 1957, 53),
woosh.Token(woosh.OP, ')', 1957, 53, 1957, 54),
woosh.Token(woosh.NEWLINE, '\r\n', 1957, 54, 1958, 0),
woosh.Token(woosh.NAME, 'return', 1958, 12, 1958, 18),
woosh.Token(woosh.NEWLINE, '\r\n', 1958, 18, 1959, 0),
woosh.Token(woosh.DEDENT, ' ', 1960, 0, 1960, 8),
woosh.Token(woosh.NAME, 'self', 1960, 8, 1960, 12),
woosh.Token(woosh.OP, '.', 1960, 12, 1960, 13),
woosh.Token(woosh.NAME, '_dbg', 1960, 13, 1960, 17),
woosh.Token(woosh.OP, '(', 1960, 17, 1960, 18),
woosh.Token(woosh.NUMBER, '1', 1960, 18, 1960, 19),
woosh.Token(woosh.OP, ',', 1960, 19, 1960, 20),
woosh.Token(woosh.NAME, 'name', 1960, 21, 1960, 25),
woosh.Token(woosh.OP, ')', 1960, 25, 1960, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 1960, 26, 1961, 0),
woosh.Token(woosh.COMMENT, '# Create a TarInfo object from the file.', 1962, 8, 1962, 48),
woosh.Token(woosh.NAME, 'tarinfo', 1963, 8, 1963, 15),
woosh.Token(woosh.OP, '=', 1963, 16, 1963, 17),
woosh.Token(woosh.NAME, 'self', 1963, 18, 1963, 22),
woosh.Token(woosh.OP, '.', 1963, 22, 1963, 23),
woosh.Token(woosh.NAME, 'gettarinfo', 1963, 23, 1963, 33),
woosh.Token(woosh.OP, '(', 1963, 33, 1963, 34),
woosh.Token(woosh.NAME, 'name', 1963, 34, 1963, 38),
woosh.Token(woosh.OP, ',', 1963, 38, 1963, 39),
woosh.Token(woosh.NAME, 'arcname', 1963, 40, 1963, 47),
woosh.Token(woosh.OP, ')', 1963, 47, 1963, 48),
woosh.Token(woosh.NEWLINE, '\r\n', 1963, 48, 1964, 0),
woosh.Token(woosh.NAME, 'if', 1965, 8, 1965, 10),
woosh.Token(woosh.NAME, 'tarinfo', 1965, 11, 1965, 18),
woosh.Token(woosh.NAME, 'is', 1965, 19, 1965, 21),
woosh.Token(woosh.NAME, 'None', 1965, 22, 1965, 26),
woosh.Token(woosh.OP, ':', 1965, 26, 1965, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 1965, 27, 1966, 0),
woosh.Token(woosh.INDENT, ' ', 1966, 0, 1966, 12),
woosh.Token(woosh.NAME, 'self', 1966, 12, 1966, 16),
woosh.Token(woosh.OP, '.', 1966, 16, 1966, 17),
woosh.Token(woosh.NAME, '_dbg', 1966, 17, 1966, 21),
woosh.Token(woosh.OP, '(', 1966, 21, 1966, 22),
woosh.Token(woosh.NUMBER, '1', 1966, 22, 1966, 23),
woosh.Token(woosh.OP, ',', 1966, 23, 1966, 24),
woosh.Token(woosh.STRING, '"tarfile: Unsupported type %r"', 1966, 25, 1966, 55),
woosh.Token(woosh.OP, '%', 1966, 56, 1966, 57),
woosh.Token(woosh.NAME, 'name', 1966, 58, 1966, 62),
woosh.Token(woosh.OP, ')', 1966, 62, 1966, 63),
woosh.Token(woosh.NEWLINE, '\r\n', 1966, 63, 1967, 0),
woosh.Token(woosh.NAME, 'return', 1967, 12, 1967, 18),
woosh.Token(woosh.NEWLINE, '\r\n', 1967, 18, 1968, 0),
woosh.Token(woosh.COMMENT, '# Change or exclude the TarInfo object.', 1969, 8, 1969, 47),
woosh.Token(woosh.DEDENT, ' ', 1970, 0, 1970, 8),
woosh.Token(woosh.NAME, 'if', 1970, 8, 1970, 10),
woosh.Token(woosh.NAME, 'filter', 1970, 11, 1970, 17),
woosh.Token(woosh.NAME, 'is', 1970, 18, 1970, 20),
woosh.Token(woosh.NAME, 'not', 1970, 21, 1970, 24),
woosh.Token(woosh.NAME, 'None', 1970, 25, 1970, 29),
woosh.Token(woosh.OP, ':', 1970, 29, 1970, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 1970, 30, 1971, 0),
woosh.Token(woosh.INDENT, ' ', 1971, 0, 1971, 12),
woosh.Token(woosh.NAME, 'tarinfo', 1971, 12, 1971, 19),
woosh.Token(woosh.OP, '=', 1971, 20, 1971, 21),
woosh.Token(woosh.NAME, 'filter', 1971, 22, 1971, 28),
woosh.Token(woosh.OP, '(', 1971, 28, 1971, 29),
woosh.Token(woosh.NAME, 'tarinfo', 1971, 29, 1971, 36),
woosh.Token(woosh.OP, ')', 1971, 36, 1971, 37),
woosh.Token(woosh.NEWLINE, '\r\n', 1971, 37, 1972, 0),
woosh.Token(woosh.NAME, 'if', 1972, 12, 1972, 14),
woosh.Token(woosh.NAME, 'tarinfo', 1972, 15, 1972, 22),
woosh.Token(woosh.NAME, 'is', 1972, 23, 1972, 25),
woosh.Token(woosh.NAME, 'None', 1972, 26, 1972, 30),
woosh.Token(woosh.OP, ':', 1972, 30, 1972, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 1972, 31, 1973, 0),
woosh.Token(woosh.INDENT, ' ', 1973, 0, 1973, 16),
woosh.Token(woosh.NAME, 'self', 1973, 16, 1973, 20),
woosh.Token(woosh.OP, '.', 1973, 20, 1973, 21),
woosh.Token(woosh.NAME, '_dbg', 1973, 21, 1973, 25),
woosh.Token(woosh.OP, '(', 1973, 25, 1973, 26),
woosh.Token(woosh.NUMBER, '2', 1973, 26, 1973, 27),
woosh.Token(woosh.OP, ',', 1973, 27, 1973, 28),
woosh.Token(woosh.STRING, '"tarfile: Excluded %r"', 1973, 29, 1973, 51),
woosh.Token(woosh.OP, '%', 1973, 52, 1973, 53),
woosh.Token(woosh.NAME, 'name', 1973, 54, 1973, 58),
woosh.Token(woosh.OP, ')', 1973, 58, 1973, 59),
woosh.Token(woosh.NEWLINE, '\r\n', 1973, 59, 1974, 0),
woosh.Token(woosh.NAME, 'return', 1974, 16, 1974, 22),
woosh.Token(woosh.NEWLINE, '\r\n', 1974, 22, 1975, 0),
woosh.Token(woosh.COMMENT, '# Append the tar header and data to the archive.', 1976, 8, 1976, 56),
woosh.Token(woosh.DEDENT, ' ', 1977, 0, 1977, 8),
woosh.Token(woosh.DEDENT, '', 1977, 8, 1977, 8),
woosh.Token(woosh.NAME, 'if', 1977, 8, 1977, 10),
woosh.Token(woosh.NAME, 'tarinfo', 1977, 11, 1977, 18),
woosh.Token(woosh.OP, '.', 1977, 18, 1977, 19),
woosh.Token(woosh.NAME, 'isreg', 1977, 19, 1977, 24),
woosh.Token(woosh.OP, '(', 1977, 24, 1977, 25),
woosh.Token(woosh.OP, ')', 1977, 25, 1977, 26),
woosh.Token(woosh.OP, ':', 1977, 26, 1977, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 1977, 27, 1978, 0),
woosh.Token(woosh.INDENT, ' ', 1978, 0, 1978, 12),
woosh.Token(woosh.NAME, 'with', 1978, 12, 1978, 16),
woosh.Token(woosh.NAME, 'bltn_open', 1978, 17, 1978, 26),
woosh.Token(woosh.OP, '(', 1978, 26, 1978, 27),
woosh.Token(woosh.NAME, 'name', 1978, 27, 1978, 31),
woosh.Token(woosh.OP, ',', 1978, 31, 1978, 32),
woosh.Token(woosh.STRING, '"rb"', 1978, 33, 1978, 37),
woosh.Token(woosh.OP, ')', 1978, 37, 1978, 38),
woosh.Token(woosh.NAME, 'as', 1978, 39, 1978, 41),
woosh.Token(woosh.NAME, 'f', 1978, 42, 1978, 43),
woosh.Token(woosh.OP, ':', 1978, 43, 1978, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 1978, 44, 1979, 0),
woosh.Token(woosh.INDENT, ' ', 1979, 0, 1979, 16),
woosh.Token(woosh.NAME, 'self', 1979, 16, 1979, 20),
woosh.Token(woosh.OP, '.', 1979, 20, 1979, 21),
woosh.Token(woosh.NAME, 'addfile', 1979, 21, 1979, 28),
woosh.Token(woosh.OP, '(', 1979, 28, 1979, 29),
woosh.Token(woosh.NAME, 'tarinfo', 1979, 29, 1979, 36),
woosh.Token(woosh.OP, ',', 1979, 36, 1979, 37),
woosh.Token(woosh.NAME, 'f', 1979, 38, 1979, 39),
woosh.Token(woosh.OP, ')', 1979, 39, 1979, 40),
woosh.Token(woosh.NEWLINE, '\r\n', 1979, 40, 1980, 0),
woosh.Token(woosh.DEDENT, ' ', 1981, 0, 1981, 8),
woosh.Token(woosh.DEDENT, '', 1981, 8, 1981, 8),
woosh.Token(woosh.NAME, 'elif', 1981, 8, 1981, 12),
woosh.Token(woosh.NAME, 'tarinfo', 1981, 13, 1981, 20),
woosh.Token(woosh.OP, '.', 1981, 20, 1981, 21),
woosh.Token(woosh.NAME, 'isdir', 1981, 21, 1981, 26),
woosh.Token(woosh.OP, '(', 1981, 26, 1981, 27),
woosh.Token(woosh.OP, ')', 1981, 27, 1981, 28),
woosh.Token(woosh.OP, ':', 1981, 28, 1981, 29),
woosh.Token(woosh.NEWLINE, '\r\n', 1981, 29, 1982, 0),
woosh.Token(woosh.INDENT, ' ', 1982, 0, 1982, 12),
woosh.Token(woosh.NAME, 'self', 1982, 12, 1982, 16),
woosh.Token(woosh.OP, '.', 1982, 16, 1982, 17),
woosh.Token(woosh.NAME, 'addfile', 1982, 17, 1982, 24),
woosh.Token(woosh.OP, '(', 1982, 24, 1982, 25),
woosh.Token(woosh.NAME, 'tarinfo', 1982, 25, 1982, 32),
woosh.Token(woosh.OP, ')', 1982, 32, 1982, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 1982, 33, 1983, 0),
woosh.Token(woosh.NAME, 'if', 1983, 12, 1983, 14),
woosh.Token(woosh.NAME, 'recursive', 1983, 15, 1983, 24),
woosh.Token(woosh.OP, ':', 1983, 24, 1983, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 1983, 25, 1984, 0),
woosh.Token(woosh.INDENT, ' ', 1984, 0, 1984, 16),
woosh.Token(woosh.NAME, 'for', 1984, 16, 1984, 19),
woosh.Token(woosh.NAME, 'f', 1984, 20, 1984, 21),
woosh.Token(woosh.NAME, 'in', 1984, 22, 1984, 24),
woosh.Token(woosh.NAME, 'sorted', 1984, 25, 1984, 31),
woosh.Token(woosh.OP, '(', 1984, 31, 1984, 32),
woosh.Token(woosh.NAME, 'os', 1984, 32, 1984, 34),
woosh.Token(woosh.OP, '.', 1984, 34, 1984, 35),
woosh.Token(woosh.NAME, 'listdir', 1984, 35, 1984, 42),
woosh.Token(woosh.OP, '(', 1984, 42, 1984, 43),
woosh.Token(woosh.NAME, 'name', 1984, 43, 1984, 47),
woosh.Token(woosh.OP, ')', 1984, 47, 1984, 48),
woosh.Token(woosh.OP, ')', 1984, 48, 1984, 49),
woosh.Token(woosh.OP, ':', 1984, 49, 1984, 50),
woosh.Token(woosh.NEWLINE, '\r\n', 1984, 50, 1985, 0),
woosh.Token(woosh.INDENT, ' ', 1985, 0, 1985, 20),
woosh.Token(woosh.NAME, 'self', 1985, 20, 1985, 24),
woosh.Token(woosh.OP, '.', 1985, 24, 1985, 25),
woosh.Token(woosh.NAME, 'add', 1985, 25, 1985, 28),
woosh.Token(woosh.OP, '(', 1985, 28, 1985, 29),
woosh.Token(woosh.NAME, 'os', 1985, 29, 1985, 31),
woosh.Token(woosh.OP, '.', 1985, 31, 1985, 32),
woosh.Token(woosh.NAME, 'path', 1985, 32, 1985, 36),
woosh.Token(woosh.OP, '.', 1985, 36, 1985, 37),
woosh.Token(woosh.NAME, 'join', 1985, 37, 1985, 41),
woosh.Token(woosh.OP, '(', 1985, 41, 1985, 42),
woosh.Token(woosh.NAME, 'name', 1985, 42, 1985, 46),
woosh.Token(woosh.OP, ',', 1985, 46, 1985, 47),
woosh.Token(woosh.NAME, 'f', 1985, 48, 1985, 49),
woosh.Token(woosh.OP, ')', 1985, 49, 1985, 50),
woosh.Token(woosh.OP, ',', 1985, 50, 1985, 51),
woosh.Token(woosh.NAME, 'os', 1985, 52, 1985, 54),
woosh.Token(woosh.OP, '.', 1985, 54, 1985, 55),
woosh.Token(woosh.NAME, 'path', 1985, 55, 1985, 59),
woosh.Token(woosh.OP, '.', 1985, 59, 1985, 60),
woosh.Token(woosh.NAME, 'join', 1985, 60, 1985, 64),
woosh.Token(woosh.OP, '(', 1985, 64, 1985, 65),
woosh.Token(woosh.NAME, 'arcname', 1985, 65, 1985, 72),
woosh.Token(woosh.OP, ',', 1985, 72, 1985, 73),
woosh.Token(woosh.NAME, 'f', 1985, 74, 1985, 75),
woosh.Token(woosh.OP, ')', 1985, 75, 1985, 76),
woosh.Token(woosh.OP, ',', 1985, 76, 1985, 77),
woosh.Token(woosh.NAME, 'recursive', 1986, 28, 1986, 37),
woosh.Token(woosh.OP, ',', 1986, 37, 1986, 38),
woosh.Token(woosh.NAME, 'filter', 1986, 39, 1986, 45),
woosh.Token(woosh.OP, '=', 1986, 45, 1986, 46),
woosh.Token(woosh.NAME, 'filter', 1986, 46, 1986, 52),
woosh.Token(woosh.OP, ')', 1986, 52, 1986, 53),
woosh.Token(woosh.NEWLINE, '\r\n', 1986, 53, 1987, 0),
woosh.Token(woosh.DEDENT, ' ', 1988, 0, 1988, 8),
woosh.Token(woosh.DEDENT, '', 1988, 8, 1988, 8),
woosh.Token(woosh.DEDENT, '', 1988, 8, 1988, 8),
woosh.Token(woosh.NAME, 'else', 1988, 8, 1988, 12),
woosh.Token(woosh.OP, ':', 1988, 12, 1988, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 1988, 13, 1989, 0),
woosh.Token(woosh.INDENT, ' ', 1989, 0, 1989, 12),
woosh.Token(woosh.NAME, 'self', 1989, 12, 1989, 16),
woosh.Token(woosh.OP, '.', 1989, 16, 1989, 17),
woosh.Token(woosh.NAME, 'addfile', 1989, 17, 1989, 24),
woosh.Token(woosh.OP, '(', 1989, 24, 1989, 25),
woosh.Token(woosh.NAME, 'tarinfo', 1989, 25, 1989, 32),
woosh.Token(woosh.OP, ')', 1989, 32, 1989, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 1989, 33, 1990, 0),
woosh.Token(woosh.DEDENT, ' ', 1991, 0, 1991, 4),
woosh.Token(woosh.DEDENT, '', 1991, 4, 1991, 4),
woosh.Token(woosh.NAME, 'def', 1991, 4, 1991, 7),
woosh.Token(woosh.NAME, 'addfile', 1991, 8, 1991, 15),
woosh.Token(woosh.OP, '(', 1991, 15, 1991, 16),
woosh.Token(woosh.NAME, 'self', 1991, 16, 1991, 20),
woosh.Token(woosh.OP, ',', 1991, 20, 1991, 21),
woosh.Token(woosh.NAME, 'tarinfo', 1991, 22, 1991, 29),
woosh.Token(woosh.OP, ',', 1991, 29, 1991, 30),
woosh.Token(woosh.NAME, 'fileobj', 1991, 31, 1991, 38),
woosh.Token(woosh.OP, '=', 1991, 38, 1991, 39),
woosh.Token(woosh.NAME, 'None', 1991, 39, 1991, 43),
woosh.Token(woosh.OP, ')', 1991, 43, 1991, 44),
woosh.Token(woosh.OP, ':', 1991, 44, 1991, 45),
woosh.Token(woosh.NEWLINE, '\r\n', 1991, 45, 1992, 0),
woosh.Token(woosh.INDENT, ' ', 1992, 0, 1992, 8),
woosh.Token(woosh.STRING, '"""Add the TarInfo object `tarinfo\' to the archive. If `fileobj\' is\r\n given, it should be a binary file, and tarinfo.size bytes are read\r\n from it and added to the archive. You can create TarInfo objects\r\n directly, or by using gettarinfo().\r\n """', 1992, 8, 1996, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 1996, 11, 1997, 0),
woosh.Token(woosh.NAME, 'self', 1997, 8, 1997, 12),
woosh.Token(woosh.OP, '.', 1997, 12, 1997, 13),
woosh.Token(woosh.NAME, '_check', 1997, 13, 1997, 19),
woosh.Token(woosh.OP, '(', 1997, 19, 1997, 20),
woosh.Token(woosh.STRING, '"awx"', 1997, 20, 1997, 25),
woosh.Token(woosh.OP, ')', 1997, 25, 1997, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 1997, 26, 1998, 0),
woosh.Token(woosh.NAME, 'tarinfo', 1999, 8, 1999, 15),
woosh.Token(woosh.OP, '=', 1999, 16, 1999, 17),
woosh.Token(woosh.NAME, 'copy', 1999, 18, 1999, 22),
woosh.Token(woosh.OP, '.', 1999, 22, 1999, 23),
woosh.Token(woosh.NAME, 'copy', 1999, 23, 1999, 27),
woosh.Token(woosh.OP, '(', 1999, 27, 1999, 28),
woosh.Token(woosh.NAME, 'tarinfo', 1999, 28, 1999, 35),
woosh.Token(woosh.OP, ')', 1999, 35, 1999, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 1999, 36, 2000, 0),
woosh.Token(woosh.NAME, 'buf', 2001, 8, 2001, 11),
woosh.Token(woosh.OP, '=', 2001, 12, 2001, 13),
woosh.Token(woosh.NAME, 'tarinfo', 2001, 14, 2001, 21),
woosh.Token(woosh.OP, '.', 2001, 21, 2001, 22),
woosh.Token(woosh.NAME, 'tobuf', 2001, 22, 2001, 27),
woosh.Token(woosh.OP, '(', 2001, 27, 2001, 28),
woosh.Token(woosh.NAME, 'self', 2001, 28, 2001, 32),
woosh.Token(woosh.OP, '.', 2001, 32, 2001, 33),
woosh.Token(woosh.NAME, 'format', 2001, 33, 2001, 39),
woosh.Token(woosh.OP, ',', 2001, 39, 2001, 40),
woosh.Token(woosh.NAME, 'self', 2001, 41, 2001, 45),
woosh.Token(woosh.OP, '.', 2001, 45, 2001, 46),
woosh.Token(woosh.NAME, 'encoding', 2001, 46, 2001, 54),
woosh.Token(woosh.OP, ',', 2001, 54, 2001, 55),
woosh.Token(woosh.NAME, 'self', 2001, 56, 2001, 60),
woosh.Token(woosh.OP, '.', 2001, 60, 2001, 61),
woosh.Token(woosh.NAME, 'errors', 2001, 61, 2001, 67),
woosh.Token(woosh.OP, ')', 2001, 67, 2001, 68),
woosh.Token(woosh.NEWLINE, '\r\n', 2001, 68, 2002, 0),
woosh.Token(woosh.NAME, 'self', 2002, 8, 2002, 12),
woosh.Token(woosh.OP, '.', 2002, 12, 2002, 13),
woosh.Token(woosh.NAME, 'fileobj', 2002, 13, 2002, 20),
woosh.Token(woosh.OP, '.', 2002, 20, 2002, 21),
woosh.Token(woosh.NAME, 'write', 2002, 21, 2002, 26),
woosh.Token(woosh.OP, '(', 2002, 26, 2002, 27),
woosh.Token(woosh.NAME, 'buf', 2002, 27, 2002, 30),
woosh.Token(woosh.OP, ')', 2002, 30, 2002, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 2002, 31, 2003, 0),
woosh.Token(woosh.NAME, 'self', 2003, 8, 2003, 12),
woosh.Token(woosh.OP, '.', 2003, 12, 2003, 13),
woosh.Token(woosh.NAME, 'offset', 2003, 13, 2003, 19),
woosh.Token(woosh.OP, '+=', 2003, 20, 2003, 22),
woosh.Token(woosh.NAME, 'len', 2003, 23, 2003, 26),
woosh.Token(woosh.OP, '(', 2003, 26, 2003, 27),
woosh.Token(woosh.NAME, 'buf', 2003, 27, 2003, 30),
woosh.Token(woosh.OP, ')', 2003, 30, 2003, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 2003, 31, 2004, 0),
woosh.Token(woosh.NAME, 'bufsize', 2004, 8, 2004, 15),
woosh.Token(woosh.OP, '=', 2004, 15, 2004, 16),
woosh.Token(woosh.NAME, 'self', 2004, 16, 2004, 20),
woosh.Token(woosh.OP, '.', 2004, 20, 2004, 21),
woosh.Token(woosh.NAME, 'copybufsize', 2004, 21, 2004, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 2004, 32, 2005, 0),
woosh.Token(woosh.COMMENT, "# If there's data to follow, append it.", 2005, 8, 2005, 47),
woosh.Token(woosh.NAME, 'if', 2006, 8, 2006, 10),
woosh.Token(woosh.NAME, 'fileobj', 2006, 11, 2006, 18),
woosh.Token(woosh.NAME, 'is', 2006, 19, 2006, 21),
woosh.Token(woosh.NAME, 'not', 2006, 22, 2006, 25),
woosh.Token(woosh.NAME, 'None', 2006, 26, 2006, 30),
woosh.Token(woosh.OP, ':', 2006, 30, 2006, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 2006, 31, 2007, 0),
woosh.Token(woosh.INDENT, ' ', 2007, 0, 2007, 12),
woosh.Token(woosh.NAME, 'copyfileobj', 2007, 12, 2007, 23),
woosh.Token(woosh.OP, '(', 2007, 23, 2007, 24),
woosh.Token(woosh.NAME, 'fileobj', 2007, 24, 2007, 31),
woosh.Token(woosh.OP, ',', 2007, 31, 2007, 32),
woosh.Token(woosh.NAME, 'self', 2007, 33, 2007, 37),
woosh.Token(woosh.OP, '.', 2007, 37, 2007, 38),
woosh.Token(woosh.NAME, 'fileobj', 2007, 38, 2007, 45),
woosh.Token(woosh.OP, ',', 2007, 45, 2007, 46),
woosh.Token(woosh.NAME, 'tarinfo', 2007, 47, 2007, 54),
woosh.Token(woosh.OP, '.', 2007, 54, 2007, 55),
woosh.Token(woosh.NAME, 'size', 2007, 55, 2007, 59),
woosh.Token(woosh.OP, ',', 2007, 59, 2007, 60),
woosh.Token(woosh.NAME, 'bufsize', 2007, 61, 2007, 68),
woosh.Token(woosh.OP, '=', 2007, 68, 2007, 69),
woosh.Token(woosh.NAME, 'bufsize', 2007, 69, 2007, 76),
woosh.Token(woosh.OP, ')', 2007, 76, 2007, 77),
woosh.Token(woosh.NEWLINE, '\r\n', 2007, 77, 2008, 0),
woosh.Token(woosh.NAME, 'blocks', 2008, 12, 2008, 18),
woosh.Token(woosh.OP, ',', 2008, 18, 2008, 19),
woosh.Token(woosh.NAME, 'remainder', 2008, 20, 2008, 29),
woosh.Token(woosh.OP, '=', 2008, 30, 2008, 31),
woosh.Token(woosh.NAME, 'divmod', 2008, 32, 2008, 38),
woosh.Token(woosh.OP, '(', 2008, 38, 2008, 39),
woosh.Token(woosh.NAME, 'tarinfo', 2008, 39, 2008, 46),
woosh.Token(woosh.OP, '.', 2008, 46, 2008, 47),
woosh.Token(woosh.NAME, 'size', 2008, 47, 2008, 51),
woosh.Token(woosh.OP, ',', 2008, 51, 2008, 52),
woosh.Token(woosh.NAME, 'BLOCKSIZE', 2008, 53, 2008, 62),
woosh.Token(woosh.OP, ')', 2008, 62, 2008, 63),
woosh.Token(woosh.NEWLINE, '\r\n', 2008, 63, 2009, 0),
woosh.Token(woosh.NAME, 'if', 2009, 12, 2009, 14),
woosh.Token(woosh.NAME, 'remainder', 2009, 15, 2009, 24),
woosh.Token(woosh.OP, '>', 2009, 25, 2009, 26),
woosh.Token(woosh.NUMBER, '0', 2009, 27, 2009, 28),
woosh.Token(woosh.OP, ':', 2009, 28, 2009, 29),
woosh.Token(woosh.NEWLINE, '\r\n', 2009, 29, 2010, 0),
woosh.Token(woosh.INDENT, ' ', 2010, 0, 2010, 16),
woosh.Token(woosh.NAME, 'self', 2010, 16, 2010, 20),
woosh.Token(woosh.OP, '.', 2010, 20, 2010, 21),
woosh.Token(woosh.NAME, 'fileobj', 2010, 21, 2010, 28),
woosh.Token(woosh.OP, '.', 2010, 28, 2010, 29),
woosh.Token(woosh.NAME, 'write', 2010, 29, 2010, 34),
woosh.Token(woosh.OP, '(', 2010, 34, 2010, 35),
woosh.Token(woosh.NAME, 'NUL', 2010, 35, 2010, 38),
woosh.Token(woosh.OP, '*', 2010, 39, 2010, 40),
woosh.Token(woosh.OP, '(', 2010, 41, 2010, 42),
woosh.Token(woosh.NAME, 'BLOCKSIZE', 2010, 42, 2010, 51),
woosh.Token(woosh.OP, '-', 2010, 52, 2010, 53),
woosh.Token(woosh.NAME, 'remainder', 2010, 54, 2010, 63),
woosh.Token(woosh.OP, ')', 2010, 63, 2010, 64),
woosh.Token(woosh.OP, ')', 2010, 64, 2010, 65),
woosh.Token(woosh.NEWLINE, '\r\n', 2010, 65, 2011, 0),
woosh.Token(woosh.NAME, 'blocks', 2011, 16, 2011, 22),
woosh.Token(woosh.OP, '+=', 2011, 23, 2011, 25),
woosh.Token(woosh.NUMBER, '1', 2011, 26, 2011, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 2011, 27, 2012, 0),
woosh.Token(woosh.DEDENT, ' ', 2012, 0, 2012, 12),
woosh.Token(woosh.NAME, 'self', 2012, 12, 2012, 16),
woosh.Token(woosh.OP, '.', 2012, 16, 2012, 17),
woosh.Token(woosh.NAME, 'offset', 2012, 17, 2012, 23),
woosh.Token(woosh.OP, '+=', 2012, 24, 2012, 26),
woosh.Token(woosh.NAME, 'blocks', 2012, 27, 2012, 33),
woosh.Token(woosh.OP, '*', 2012, 34, 2012, 35),
woosh.Token(woosh.NAME, 'BLOCKSIZE', 2012, 36, 2012, 45),
woosh.Token(woosh.NEWLINE, '\r\n', 2012, 45, 2013, 0),
woosh.Token(woosh.DEDENT, ' ', 2014, 0, 2014, 8),
woosh.Token(woosh.NAME, 'self', 2014, 8, 2014, 12),
woosh.Token(woosh.OP, '.', 2014, 12, 2014, 13),
woosh.Token(woosh.NAME, 'members', 2014, 13, 2014, 20),
woosh.Token(woosh.OP, '.', 2014, 20, 2014, 21),
woosh.Token(woosh.NAME, 'append', 2014, 21, 2014, 27),
woosh.Token(woosh.OP, '(', 2014, 27, 2014, 28),
woosh.Token(woosh.NAME, 'tarinfo', 2014, 28, 2014, 35),
woosh.Token(woosh.OP, ')', 2014, 35, 2014, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 2014, 36, 2015, 0),
woosh.Token(woosh.DEDENT, ' ', 2016, 0, 2016, 4),
woosh.Token(woosh.NAME, 'def', 2016, 4, 2016, 7),
woosh.Token(woosh.NAME, 'extractall', 2016, 8, 2016, 18),
woosh.Token(woosh.OP, '(', 2016, 18, 2016, 19),
woosh.Token(woosh.NAME, 'self', 2016, 19, 2016, 23),
woosh.Token(woosh.OP, ',', 2016, 23, 2016, 24),
woosh.Token(woosh.NAME, 'path', 2016, 25, 2016, 29),
woosh.Token(woosh.OP, '=', 2016, 29, 2016, 30),
woosh.Token(woosh.STRING, '"."', 2016, 30, 2016, 33),
woosh.Token(woosh.OP, ',', 2016, 33, 2016, 34),
woosh.Token(woosh.NAME, 'members', 2016, 35, 2016, 42),
woosh.Token(woosh.OP, '=', 2016, 42, 2016, 43),
woosh.Token(woosh.NAME, 'None', 2016, 43, 2016, 47),
woosh.Token(woosh.OP, ',', 2016, 47, 2016, 48),
woosh.Token(woosh.OP, '*', 2016, 49, 2016, 50),
woosh.Token(woosh.OP, ',', 2016, 50, 2016, 51),
woosh.Token(woosh.NAME, 'numeric_owner', 2016, 52, 2016, 65),
woosh.Token(woosh.OP, '=', 2016, 65, 2016, 66),
woosh.Token(woosh.NAME, 'False', 2016, 66, 2016, 71),
woosh.Token(woosh.OP, ')', 2016, 71, 2016, 72),
woosh.Token(woosh.OP, ':', 2016, 72, 2016, 73),
woosh.Token(woosh.NEWLINE, '\r\n', 2016, 73, 2017, 0),
woosh.Token(woosh.INDENT, ' ', 2017, 0, 2017, 8),
woosh.Token(woosh.STRING, '"""Extract all members from the archive to the current working\r\n directory and set owner, modification time and permissions on\r\n directories afterwards. `path\' specifies a different directory\r\n to extract to. `members\' is optional and must be a subset of the\r\n list returned by getmembers(). If `numeric_owner` is True, only\r\n the numbers for user/group names are used and not the names.\r\n """', 2017, 8, 2023, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 2023, 11, 2024, 0),
woosh.Token(woosh.NAME, 'directories', 2024, 8, 2024, 19),
woosh.Token(woosh.OP, '=', 2024, 20, 2024, 21),
woosh.Token(woosh.OP, '[', 2024, 22, 2024, 23),
woosh.Token(woosh.OP, ']', 2024, 23, 2024, 24),
woosh.Token(woosh.NEWLINE, '\r\n', 2024, 24, 2025, 0),
woosh.Token(woosh.NAME, 'if', 2026, 8, 2026, 10),
woosh.Token(woosh.NAME, 'members', 2026, 11, 2026, 18),
woosh.Token(woosh.NAME, 'is', 2026, 19, 2026, 21),
woosh.Token(woosh.NAME, 'None', 2026, 22, 2026, 26),
woosh.Token(woosh.OP, ':', 2026, 26, 2026, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 2026, 27, 2027, 0),
woosh.Token(woosh.INDENT, ' ', 2027, 0, 2027, 12),
woosh.Token(woosh.NAME, 'members', 2027, 12, 2027, 19),
woosh.Token(woosh.OP, '=', 2027, 20, 2027, 21),
woosh.Token(woosh.NAME, 'self', 2027, 22, 2027, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 2027, 26, 2028, 0),
woosh.Token(woosh.DEDENT, ' ', 2029, 0, 2029, 8),
woosh.Token(woosh.NAME, 'for', 2029, 8, 2029, 11),
woosh.Token(woosh.NAME, 'tarinfo', 2029, 12, 2029, 19),
woosh.Token(woosh.NAME, 'in', 2029, 20, 2029, 22),
woosh.Token(woosh.NAME, 'members', 2029, 23, 2029, 30),
woosh.Token(woosh.OP, ':', 2029, 30, 2029, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 2029, 31, 2030, 0),
woosh.Token(woosh.INDENT, ' ', 2030, 0, 2030, 12),
woosh.Token(woosh.NAME, 'if', 2030, 12, 2030, 14),
woosh.Token(woosh.NAME, 'tarinfo', 2030, 15, 2030, 22),
woosh.Token(woosh.OP, '.', 2030, 22, 2030, 23),
woosh.Token(woosh.NAME, 'isdir', 2030, 23, 2030, 28),
woosh.Token(woosh.OP, '(', 2030, 28, 2030, 29),
woosh.Token(woosh.OP, ')', 2030, 29, 2030, 30),
woosh.Token(woosh.OP, ':', 2030, 30, 2030, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 2030, 31, 2031, 0),
woosh.Token(woosh.COMMENT, '# Extract directories with a safe mode.', 2031, 16, 2031, 55),
woosh.Token(woosh.INDENT, ' ', 2032, 0, 2032, 16),
woosh.Token(woosh.NAME, 'directories', 2032, 16, 2032, 27),
woosh.Token(woosh.OP, '.', 2032, 27, 2032, 28),
woosh.Token(woosh.NAME, 'append', 2032, 28, 2032, 34),
woosh.Token(woosh.OP, '(', 2032, 34, 2032, 35),
woosh.Token(woosh.NAME, 'tarinfo', 2032, 35, 2032, 42),
woosh.Token(woosh.OP, ')', 2032, 42, 2032, 43),
woosh.Token(woosh.NEWLINE, '\r\n', 2032, 43, 2033, 0),
woosh.Token(woosh.NAME, 'tarinfo', 2033, 16, 2033, 23),
woosh.Token(woosh.OP, '=', 2033, 24, 2033, 25),
woosh.Token(woosh.NAME, 'copy', 2033, 26, 2033, 30),
woosh.Token(woosh.OP, '.', 2033, 30, 2033, 31),
woosh.Token(woosh.NAME, 'copy', 2033, 31, 2033, 35),
woosh.Token(woosh.OP, '(', 2033, 35, 2033, 36),
woosh.Token(woosh.NAME, 'tarinfo', 2033, 36, 2033, 43),
woosh.Token(woosh.OP, ')', 2033, 43, 2033, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 2033, 44, 2034, 0),
woosh.Token(woosh.NAME, 'tarinfo', 2034, 16, 2034, 23),
woosh.Token(woosh.OP, '.', 2034, 23, 2034, 24),
woosh.Token(woosh.NAME, 'mode', 2034, 24, 2034, 28),
woosh.Token(woosh.OP, '=', 2034, 29, 2034, 30),
woosh.Token(woosh.NUMBER, '0o700', 2034, 31, 2034, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 2034, 36, 2035, 0),
woosh.Token(woosh.COMMENT, '# Do not set_attrs directories, as we will do that further down', 2035, 12, 2035, 75),
woosh.Token(woosh.DEDENT, ' ', 2036, 0, 2036, 12),
woosh.Token(woosh.NAME, 'self', 2036, 12, 2036, 16),
woosh.Token(woosh.OP, '.', 2036, 16, 2036, 17),
woosh.Token(woosh.NAME, 'extract', 2036, 17, 2036, 24),
woosh.Token(woosh.OP, '(', 2036, 24, 2036, 25),
woosh.Token(woosh.NAME, 'tarinfo', 2036, 25, 2036, 32),
woosh.Token(woosh.OP, ',', 2036, 32, 2036, 33),
woosh.Token(woosh.NAME, 'path', 2036, 34, 2036, 38),
woosh.Token(woosh.OP, ',', 2036, 38, 2036, 39),
woosh.Token(woosh.NAME, 'set_attrs', 2036, 40, 2036, 49),
woosh.Token(woosh.OP, '=', 2036, 49, 2036, 50),
woosh.Token(woosh.NAME, 'not', 2036, 50, 2036, 53),
woosh.Token(woosh.NAME, 'tarinfo', 2036, 54, 2036, 61),
woosh.Token(woosh.OP, '.', 2036, 61, 2036, 62),
woosh.Token(woosh.NAME, 'isdir', 2036, 62, 2036, 67),
woosh.Token(woosh.OP, '(', 2036, 67, 2036, 68),
woosh.Token(woosh.OP, ')', 2036, 68, 2036, 69),
woosh.Token(woosh.OP, ',', 2036, 69, 2036, 70),
woosh.Token(woosh.NAME, 'numeric_owner', 2037, 25, 2037, 38),
woosh.Token(woosh.OP, '=', 2037, 38, 2037, 39),
woosh.Token(woosh.NAME, 'numeric_owner', 2037, 39, 2037, 52),
woosh.Token(woosh.OP, ')', 2037, 52, 2037, 53),
woosh.Token(woosh.NEWLINE, '\r\n', 2037, 53, 2038, 0),
woosh.Token(woosh.COMMENT, '# Reverse sort directories.', 2039, 8, 2039, 35),
woosh.Token(woosh.DEDENT, ' ', 2040, 0, 2040, 8),
woosh.Token(woosh.NAME, 'directories', 2040, 8, 2040, 19),
woosh.Token(woosh.OP, '.', 2040, 19, 2040, 20),
woosh.Token(woosh.NAME, 'sort', 2040, 20, 2040, 24),
woosh.Token(woosh.OP, '(', 2040, 24, 2040, 25),
woosh.Token(woosh.NAME, 'key', 2040, 25, 2040, 28),
woosh.Token(woosh.OP, '=', 2040, 28, 2040, 29),
woosh.Token(woosh.NAME, 'lambda', 2040, 29, 2040, 35),
woosh.Token(woosh.NAME, 'a', 2040, 36, 2040, 37),
woosh.Token(woosh.OP, ':', 2040, 37, 2040, 38),
woosh.Token(woosh.NAME, 'a', 2040, 39, 2040, 40),
woosh.Token(woosh.OP, '.', 2040, 40, 2040, 41),
woosh.Token(woosh.NAME, 'name', 2040, 41, 2040, 45),
woosh.Token(woosh.OP, ')', 2040, 45, 2040, 46),
woosh.Token(woosh.NEWLINE, '\r\n', 2040, 46, 2041, 0),
woosh.Token(woosh.NAME, 'directories', 2041, 8, 2041, 19),
woosh.Token(woosh.OP, '.', 2041, 19, 2041, 20),
woosh.Token(woosh.NAME, 'reverse', 2041, 20, 2041, 27),
woosh.Token(woosh.OP, '(', 2041, 27, 2041, 28),
woosh.Token(woosh.OP, ')', 2041, 28, 2041, 29),
woosh.Token(woosh.NEWLINE, '\r\n', 2041, 29, 2042, 0),
woosh.Token(woosh.COMMENT, '# Set correct owner, mtime and filemode on directories.', 2043, 8, 2043, 63),
woosh.Token(woosh.NAME, 'for', 2044, 8, 2044, 11),
woosh.Token(woosh.NAME, 'tarinfo', 2044, 12, 2044, 19),
woosh.Token(woosh.NAME, 'in', 2044, 20, 2044, 22),
woosh.Token(woosh.NAME, 'directories', 2044, 23, 2044, 34),
woosh.Token(woosh.OP, ':', 2044, 34, 2044, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 2044, 35, 2045, 0),
woosh.Token(woosh.INDENT, ' ', 2045, 0, 2045, 12),
woosh.Token(woosh.NAME, 'dirpath', 2045, 12, 2045, 19),
woosh.Token(woosh.OP, '=', 2045, 20, 2045, 21),
woosh.Token(woosh.NAME, 'os', 2045, 22, 2045, 24),
woosh.Token(woosh.OP, '.', 2045, 24, 2045, 25),
woosh.Token(woosh.NAME, 'path', 2045, 25, 2045, 29),
woosh.Token(woosh.OP, '.', 2045, 29, 2045, 30),
woosh.Token(woosh.NAME, 'join', 2045, 30, 2045, 34),
woosh.Token(woosh.OP, '(', 2045, 34, 2045, 35),
woosh.Token(woosh.NAME, 'path', 2045, 35, 2045, 39),
woosh.Token(woosh.OP, ',', 2045, 39, 2045, 40),
woosh.Token(woosh.NAME, 'tarinfo', 2045, 41, 2045, 48),
woosh.Token(woosh.OP, '.', 2045, 48, 2045, 49),
woosh.Token(woosh.NAME, 'name', 2045, 49, 2045, 53),
woosh.Token(woosh.OP, ')', 2045, 53, 2045, 54),
woosh.Token(woosh.NEWLINE, '\r\n', 2045, 54, 2046, 0),
woosh.Token(woosh.NAME, 'try', 2046, 12, 2046, 15),
woosh.Token(woosh.OP, ':', 2046, 15, 2046, 16),
woosh.Token(woosh.NEWLINE, '\r\n', 2046, 16, 2047, 0),
woosh.Token(woosh.INDENT, ' ', 2047, 0, 2047, 16),
woosh.Token(woosh.NAME, 'self', 2047, 16, 2047, 20),
woosh.Token(woosh.OP, '.', 2047, 20, 2047, 21),
woosh.Token(woosh.NAME, 'chown', 2047, 21, 2047, 26),
woosh.Token(woosh.OP, '(', 2047, 26, 2047, 27),
woosh.Token(woosh.NAME, 'tarinfo', 2047, 27, 2047, 34),
woosh.Token(woosh.OP, ',', 2047, 34, 2047, 35),
woosh.Token(woosh.NAME, 'dirpath', 2047, 36, 2047, 43),
woosh.Token(woosh.OP, ',', 2047, 43, 2047, 44),
woosh.Token(woosh.NAME, 'numeric_owner', 2047, 45, 2047, 58),
woosh.Token(woosh.OP, '=', 2047, 58, 2047, 59),
woosh.Token(woosh.NAME, 'numeric_owner', 2047, 59, 2047, 72),
woosh.Token(woosh.OP, ')', 2047, 72, 2047, 73),
woosh.Token(woosh.NEWLINE, '\r\n', 2047, 73, 2048, 0),
woosh.Token(woosh.NAME, 'self', 2048, 16, 2048, 20),
woosh.Token(woosh.OP, '.', 2048, 20, 2048, 21),
woosh.Token(woosh.NAME, 'utime', 2048, 21, 2048, 26),
woosh.Token(woosh.OP, '(', 2048, 26, 2048, 27),
woosh.Token(woosh.NAME, 'tarinfo', 2048, 27, 2048, 34),
woosh.Token(woosh.OP, ',', 2048, 34, 2048, 35),
woosh.Token(woosh.NAME, 'dirpath', 2048, 36, 2048, 43),
woosh.Token(woosh.OP, ')', 2048, 43, 2048, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 2048, 44, 2049, 0),
woosh.Token(woosh.NAME, 'self', 2049, 16, 2049, 20),
woosh.Token(woosh.OP, '.', 2049, 20, 2049, 21),
woosh.Token(woosh.NAME, 'chmod', 2049, 21, 2049, 26),
woosh.Token(woosh.OP, '(', 2049, 26, 2049, 27),
woosh.Token(woosh.NAME, 'tarinfo', 2049, 27, 2049, 34),
woosh.Token(woosh.OP, ',', 2049, 34, 2049, 35),
woosh.Token(woosh.NAME, 'dirpath', 2049, 36, 2049, 43),
woosh.Token(woosh.OP, ')', 2049, 43, 2049, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 2049, 44, 2050, 0),
woosh.Token(woosh.DEDENT, ' ', 2050, 0, 2050, 12),
woosh.Token(woosh.NAME, 'except', 2050, 12, 2050, 18),
woosh.Token(woosh.NAME, 'ExtractError', 2050, 19, 2050, 31),
woosh.Token(woosh.NAME, 'as', 2050, 32, 2050, 34),
woosh.Token(woosh.NAME, 'e', 2050, 35, 2050, 36),
woosh.Token(woosh.OP, ':', 2050, 36, 2050, 37),
woosh.Token(woosh.NEWLINE, '\r\n', 2050, 37, 2051, 0),
woosh.Token(woosh.INDENT, ' ', 2051, 0, 2051, 16),
woosh.Token(woosh.NAME, 'if', 2051, 16, 2051, 18),
woosh.Token(woosh.NAME, 'self', 2051, 19, 2051, 23),
woosh.Token(woosh.OP, '.', 2051, 23, 2051, 24),
woosh.Token(woosh.NAME, 'errorlevel', 2051, 24, 2051, 34),
woosh.Token(woosh.OP, '>', 2051, 35, 2051, 36),
woosh.Token(woosh.NUMBER, '1', 2051, 37, 2051, 38),
woosh.Token(woosh.OP, ':', 2051, 38, 2051, 39),
woosh.Token(woosh.NEWLINE, '\r\n', 2051, 39, 2052, 0),
woosh.Token(woosh.INDENT, ' ', 2052, 0, 2052, 20),
woosh.Token(woosh.NAME, 'raise', 2052, 20, 2052, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 2052, 25, 2053, 0),
woosh.Token(woosh.DEDENT, ' ', 2053, 0, 2053, 16),
woosh.Token(woosh.NAME, 'else', 2053, 16, 2053, 20),
woosh.Token(woosh.OP, ':', 2053, 20, 2053, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 2053, 21, 2054, 0),
woosh.Token(woosh.INDENT, ' ', 2054, 0, 2054, 20),
woosh.Token(woosh.NAME, 'self', 2054, 20, 2054, 24),
woosh.Token(woosh.OP, '.', 2054, 24, 2054, 25),
woosh.Token(woosh.NAME, '_dbg', 2054, 25, 2054, 29),
woosh.Token(woosh.OP, '(', 2054, 29, 2054, 30),
woosh.Token(woosh.NUMBER, '1', 2054, 30, 2054, 31),
woosh.Token(woosh.OP, ',', 2054, 31, 2054, 32),
woosh.Token(woosh.STRING, '"tarfile: %s"', 2054, 33, 2054, 46),
woosh.Token(woosh.OP, '%', 2054, 47, 2054, 48),
woosh.Token(woosh.NAME, 'e', 2054, 49, 2054, 50),
woosh.Token(woosh.OP, ')', 2054, 50, 2054, 51),
woosh.Token(woosh.NEWLINE, '\r\n', 2054, 51, 2055, 0),
woosh.Token(woosh.DEDENT, ' ', 2056, 0, 2056, 4),
woosh.Token(woosh.DEDENT, '', 2056, 4, 2056, 4),
woosh.Token(woosh.DEDENT, '', 2056, 4, 2056, 4),
woosh.Token(woosh.DEDENT, '', 2056, 4, 2056, 4),
woosh.Token(woosh.NAME, 'def', 2056, 4, 2056, 7),
woosh.Token(woosh.NAME, 'extract', 2056, 8, 2056, 15),
woosh.Token(woosh.OP, '(', 2056, 15, 2056, 16),
woosh.Token(woosh.NAME, 'self', 2056, 16, 2056, 20),
woosh.Token(woosh.OP, ',', 2056, 20, 2056, 21),
woosh.Token(woosh.NAME, 'member', 2056, 22, 2056, 28),
woosh.Token(woosh.OP, ',', 2056, 28, 2056, 29),
woosh.Token(woosh.NAME, 'path', 2056, 30, 2056, 34),
woosh.Token(woosh.OP, '=', 2056, 34, 2056, 35),
woosh.Token(woosh.STRING, '""', 2056, 35, 2056, 37),
woosh.Token(woosh.OP, ',', 2056, 37, 2056, 38),
woosh.Token(woosh.NAME, 'set_attrs', 2056, 39, 2056, 48),
woosh.Token(woosh.OP, '=', 2056, 48, 2056, 49),
woosh.Token(woosh.NAME, 'True', 2056, 49, 2056, 53),
woosh.Token(woosh.OP, ',', 2056, 53, 2056, 54),
woosh.Token(woosh.OP, '*', 2056, 55, 2056, 56),
woosh.Token(woosh.OP, ',', 2056, 56, 2056, 57),
woosh.Token(woosh.NAME, 'numeric_owner', 2056, 58, 2056, 71),
woosh.Token(woosh.OP, '=', 2056, 71, 2056, 72),
woosh.Token(woosh.NAME, 'False', 2056, 72, 2056, 77),
woosh.Token(woosh.OP, ')', 2056, 77, 2056, 78),
woosh.Token(woosh.OP, ':', 2056, 78, 2056, 79),
woosh.Token(woosh.NEWLINE, '\r\n', 2056, 79, 2057, 0),
woosh.Token(woosh.INDENT, ' ', 2057, 0, 2057, 8),
woosh.Token(woosh.STRING, '"""Extract a member from the archive to the current working directory,\r\n using its full name. Its file information is extracted as accurately\r\n as possible. `member\' may be a filename or a TarInfo object. You can\r\n specify a different directory using `path\'. File attributes (owner,\r\n mtime, mode) are set unless `set_attrs\' is False. If `numeric_owner`\r\n is True, only the numbers for user/group names are used and not\r\n the names.\r\n """', 2057, 8, 2064, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 2064, 11, 2065, 0),
woosh.Token(woosh.NAME, 'self', 2065, 8, 2065, 12),
woosh.Token(woosh.OP, '.', 2065, 12, 2065, 13),
woosh.Token(woosh.NAME, '_check', 2065, 13, 2065, 19),
woosh.Token(woosh.OP, '(', 2065, 19, 2065, 20),
woosh.Token(woosh.STRING, '"r"', 2065, 20, 2065, 23),
woosh.Token(woosh.OP, ')', 2065, 23, 2065, 24),
woosh.Token(woosh.NEWLINE, '\r\n', 2065, 24, 2066, 0),
woosh.Token(woosh.NAME, 'if', 2067, 8, 2067, 10),
woosh.Token(woosh.NAME, 'isinstance', 2067, 11, 2067, 21),
woosh.Token(woosh.OP, '(', 2067, 21, 2067, 22),
woosh.Token(woosh.NAME, 'member', 2067, 22, 2067, 28),
woosh.Token(woosh.OP, ',', 2067, 28, 2067, 29),
woosh.Token(woosh.NAME, 'str', 2067, 30, 2067, 33),
woosh.Token(woosh.OP, ')', 2067, 33, 2067, 34),
woosh.Token(woosh.OP, ':', 2067, 34, 2067, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 2067, 35, 2068, 0),
woosh.Token(woosh.INDENT, ' ', 2068, 0, 2068, 12),
woosh.Token(woosh.NAME, 'tarinfo', 2068, 12, 2068, 19),
woosh.Token(woosh.OP, '=', 2068, 20, 2068, 21),
woosh.Token(woosh.NAME, 'self', 2068, 22, 2068, 26),
woosh.Token(woosh.OP, '.', 2068, 26, 2068, 27),
woosh.Token(woosh.NAME, 'getmember', 2068, 27, 2068, 36),
woosh.Token(woosh.OP, '(', 2068, 36, 2068, 37),
woosh.Token(woosh.NAME, 'member', 2068, 37, 2068, 43),
woosh.Token(woosh.OP, ')', 2068, 43, 2068, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 2068, 44, 2069, 0),
woosh.Token(woosh.DEDENT, ' ', 2069, 0, 2069, 8),
woosh.Token(woosh.NAME, 'else', 2069, 8, 2069, 12),
woosh.Token(woosh.OP, ':', 2069, 12, 2069, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 2069, 13, 2070, 0),
woosh.Token(woosh.INDENT, ' ', 2070, 0, 2070, 12),
woosh.Token(woosh.NAME, 'tarinfo', 2070, 12, 2070, 19),
woosh.Token(woosh.OP, '=', 2070, 20, 2070, 21),
woosh.Token(woosh.NAME, 'member', 2070, 22, 2070, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 2070, 28, 2071, 0),
woosh.Token(woosh.COMMENT, '# Prepare the link target for makelink().', 2072, 8, 2072, 49),
woosh.Token(woosh.DEDENT, ' ', 2073, 0, 2073, 8),
woosh.Token(woosh.NAME, 'if', 2073, 8, 2073, 10),
woosh.Token(woosh.NAME, 'tarinfo', 2073, 11, 2073, 18),
woosh.Token(woosh.OP, '.', 2073, 18, 2073, 19),
woosh.Token(woosh.NAME, 'islnk', 2073, 19, 2073, 24),
woosh.Token(woosh.OP, '(', 2073, 24, 2073, 25),
woosh.Token(woosh.OP, ')', 2073, 25, 2073, 26),
woosh.Token(woosh.OP, ':', 2073, 26, 2073, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 2073, 27, 2074, 0),
woosh.Token(woosh.INDENT, ' ', 2074, 0, 2074, 12),
woosh.Token(woosh.NAME, 'tarinfo', 2074, 12, 2074, 19),
woosh.Token(woosh.OP, '.', 2074, 19, 2074, 20),
woosh.Token(woosh.NAME, '_link_target', 2074, 20, 2074, 32),
woosh.Token(woosh.OP, '=', 2074, 33, 2074, 34),
woosh.Token(woosh.NAME, 'os', 2074, 35, 2074, 37),
woosh.Token(woosh.OP, '.', 2074, 37, 2074, 38),
woosh.Token(woosh.NAME, 'path', 2074, 38, 2074, 42),
woosh.Token(woosh.OP, '.', 2074, 42, 2074, 43),
woosh.Token(woosh.NAME, 'join', 2074, 43, 2074, 47),
woosh.Token(woosh.OP, '(', 2074, 47, 2074, 48),
woosh.Token(woosh.NAME, 'path', 2074, 48, 2074, 52),
woosh.Token(woosh.OP, ',', 2074, 52, 2074, 53),
woosh.Token(woosh.NAME, 'tarinfo', 2074, 54, 2074, 61),
woosh.Token(woosh.OP, '.', 2074, 61, 2074, 62),
woosh.Token(woosh.NAME, 'linkname', 2074, 62, 2074, 70),
woosh.Token(woosh.OP, ')', 2074, 70, 2074, 71),
woosh.Token(woosh.NEWLINE, '\r\n', 2074, 71, 2075, 0),
woosh.Token(woosh.DEDENT, ' ', 2076, 0, 2076, 8),
woosh.Token(woosh.NAME, 'try', 2076, 8, 2076, 11),
woosh.Token(woosh.OP, ':', 2076, 11, 2076, 12),
woosh.Token(woosh.NEWLINE, '\r\n', 2076, 12, 2077, 0),
woosh.Token(woosh.INDENT, ' ', 2077, 0, 2077, 12),
woosh.Token(woosh.NAME, 'self', 2077, 12, 2077, 16),
woosh.Token(woosh.OP, '.', 2077, 16, 2077, 17),
woosh.Token(woosh.NAME, '_extract_member', 2077, 17, 2077, 32),
woosh.Token(woosh.OP, '(', 2077, 32, 2077, 33),
woosh.Token(woosh.NAME, 'tarinfo', 2077, 33, 2077, 40),
woosh.Token(woosh.OP, ',', 2077, 40, 2077, 41),
woosh.Token(woosh.NAME, 'os', 2077, 42, 2077, 44),
woosh.Token(woosh.OP, '.', 2077, 44, 2077, 45),
woosh.Token(woosh.NAME, 'path', 2077, 45, 2077, 49),
woosh.Token(woosh.OP, '.', 2077, 49, 2077, 50),
woosh.Token(woosh.NAME, 'join', 2077, 50, 2077, 54),
woosh.Token(woosh.OP, '(', 2077, 54, 2077, 55),
woosh.Token(woosh.NAME, 'path', 2077, 55, 2077, 59),
woosh.Token(woosh.OP, ',', 2077, 59, 2077, 60),
woosh.Token(woosh.NAME, 'tarinfo', 2077, 61, 2077, 68),
woosh.Token(woosh.OP, '.', 2077, 68, 2077, 69),
woosh.Token(woosh.NAME, 'name', 2077, 69, 2077, 73),
woosh.Token(woosh.OP, ')', 2077, 73, 2077, 74),
woosh.Token(woosh.OP, ',', 2077, 74, 2077, 75),
woosh.Token(woosh.NAME, 'set_attrs', 2078, 33, 2078, 42),
woosh.Token(woosh.OP, '=', 2078, 42, 2078, 43),
woosh.Token(woosh.NAME, 'set_attrs', 2078, 43, 2078, 52),
woosh.Token(woosh.OP, ',', 2078, 52, 2078, 53),
woosh.Token(woosh.NAME, 'numeric_owner', 2079, 33, 2079, 46),
woosh.Token(woosh.OP, '=', 2079, 46, 2079, 47),
woosh.Token(woosh.NAME, 'numeric_owner', 2079, 47, 2079, 60),
woosh.Token(woosh.OP, ')', 2079, 60, 2079, 61),
woosh.Token(woosh.NEWLINE, '\r\n', 2079, 61, 2080, 0),
woosh.Token(woosh.DEDENT, ' ', 2080, 0, 2080, 8),
woosh.Token(woosh.NAME, 'except', 2080, 8, 2080, 14),
woosh.Token(woosh.NAME, 'OSError', 2080, 15, 2080, 22),
woosh.Token(woosh.NAME, 'as', 2080, 23, 2080, 25),
woosh.Token(woosh.NAME, 'e', 2080, 26, 2080, 27),
woosh.Token(woosh.OP, ':', 2080, 27, 2080, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 2080, 28, 2081, 0),
woosh.Token(woosh.INDENT, ' ', 2081, 0, 2081, 12),
woosh.Token(woosh.NAME, 'if', 2081, 12, 2081, 14),
woosh.Token(woosh.NAME, 'self', 2081, 15, 2081, 19),
woosh.Token(woosh.OP, '.', 2081, 19, 2081, 20),
woosh.Token(woosh.NAME, 'errorlevel', 2081, 20, 2081, 30),
woosh.Token(woosh.OP, '>', 2081, 31, 2081, 32),
woosh.Token(woosh.NUMBER, '0', 2081, 33, 2081, 34),
woosh.Token(woosh.OP, ':', 2081, 34, 2081, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 2081, 35, 2082, 0),
woosh.Token(woosh.INDENT, ' ', 2082, 0, 2082, 16),
woosh.Token(woosh.NAME, 'raise', 2082, 16, 2082, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 2082, 21, 2083, 0),
woosh.Token(woosh.DEDENT, ' ', 2083, 0, 2083, 12),
woosh.Token(woosh.NAME, 'else', 2083, 12, 2083, 16),
woosh.Token(woosh.OP, ':', 2083, 16, 2083, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 2083, 17, 2084, 0),
woosh.Token(woosh.INDENT, ' ', 2084, 0, 2084, 16),
woosh.Token(woosh.NAME, 'if', 2084, 16, 2084, 18),
woosh.Token(woosh.NAME, 'e', 2084, 19, 2084, 20),
woosh.Token(woosh.OP, '.', 2084, 20, 2084, 21),
woosh.Token(woosh.NAME, 'filename', 2084, 21, 2084, 29),
woosh.Token(woosh.NAME, 'is', 2084, 30, 2084, 32),
woosh.Token(woosh.NAME, 'None', 2084, 33, 2084, 37),
woosh.Token(woosh.OP, ':', 2084, 37, 2084, 38),
woosh.Token(woosh.NEWLINE, '\r\n', 2084, 38, 2085, 0),
woosh.Token(woosh.INDENT, ' ', 2085, 0, 2085, 20),
woosh.Token(woosh.NAME, 'self', 2085, 20, 2085, 24),
woosh.Token(woosh.OP, '.', 2085, 24, 2085, 25),
woosh.Token(woosh.NAME, '_dbg', 2085, 25, 2085, 29),
woosh.Token(woosh.OP, '(', 2085, 29, 2085, 30),
woosh.Token(woosh.NUMBER, '1', 2085, 30, 2085, 31),
woosh.Token(woosh.OP, ',', 2085, 31, 2085, 32),
woosh.Token(woosh.STRING, '"tarfile: %s"', 2085, 33, 2085, 46),
woosh.Token(woosh.OP, '%', 2085, 47, 2085, 48),
woosh.Token(woosh.NAME, 'e', 2085, 49, 2085, 50),
woosh.Token(woosh.OP, '.', 2085, 50, 2085, 51),
woosh.Token(woosh.NAME, 'strerror', 2085, 51, 2085, 59),
woosh.Token(woosh.OP, ')', 2085, 59, 2085, 60),
woosh.Token(woosh.NEWLINE, '\r\n', 2085, 60, 2086, 0),
woosh.Token(woosh.DEDENT, ' ', 2086, 0, 2086, 16),
woosh.Token(woosh.NAME, 'else', 2086, 16, 2086, 20),
woosh.Token(woosh.OP, ':', 2086, 20, 2086, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 2086, 21, 2087, 0),
woosh.Token(woosh.INDENT, ' ', 2087, 0, 2087, 20),
woosh.Token(woosh.NAME, 'self', 2087, 20, 2087, 24),
woosh.Token(woosh.OP, '.', 2087, 24, 2087, 25),
woosh.Token(woosh.NAME, '_dbg', 2087, 25, 2087, 29),
woosh.Token(woosh.OP, '(', 2087, 29, 2087, 30),
woosh.Token(woosh.NUMBER, '1', 2087, 30, 2087, 31),
woosh.Token(woosh.OP, ',', 2087, 31, 2087, 32),
woosh.Token(woosh.STRING, '"tarfile: %s %r"', 2087, 33, 2087, 49),
woosh.Token(woosh.OP, '%', 2087, 50, 2087, 51),
woosh.Token(woosh.OP, '(', 2087, 52, 2087, 53),
woosh.Token(woosh.NAME, 'e', 2087, 53, 2087, 54),
woosh.Token(woosh.OP, '.', 2087, 54, 2087, 55),
woosh.Token(woosh.NAME, 'strerror', 2087, 55, 2087, 63),
woosh.Token(woosh.OP, ',', 2087, 63, 2087, 64),
woosh.Token(woosh.NAME, 'e', 2087, 65, 2087, 66),
woosh.Token(woosh.OP, '.', 2087, 66, 2087, 67),
woosh.Token(woosh.NAME, 'filename', 2087, 67, 2087, 75),
woosh.Token(woosh.OP, ')', 2087, 75, 2087, 76),
woosh.Token(woosh.OP, ')', 2087, 76, 2087, 77),
woosh.Token(woosh.NEWLINE, '\r\n', 2087, 77, 2088, 0),
woosh.Token(woosh.DEDENT, ' ', 2088, 0, 2088, 8),
woosh.Token(woosh.DEDENT, '', 2088, 8, 2088, 8),
woosh.Token(woosh.DEDENT, '', 2088, 8, 2088, 8),
woosh.Token(woosh.NAME, 'except', 2088, 8, 2088, 14),
woosh.Token(woosh.NAME, 'ExtractError', 2088, 15, 2088, 27),
woosh.Token(woosh.NAME, 'as', 2088, 28, 2088, 30),
woosh.Token(woosh.NAME, 'e', 2088, 31, 2088, 32),
woosh.Token(woosh.OP, ':', 2088, 32, 2088, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 2088, 33, 2089, 0),
woosh.Token(woosh.INDENT, ' ', 2089, 0, 2089, 12),
woosh.Token(woosh.NAME, 'if', 2089, 12, 2089, 14),
woosh.Token(woosh.NAME, 'self', 2089, 15, 2089, 19),
woosh.Token(woosh.OP, '.', 2089, 19, 2089, 20),
woosh.Token(woosh.NAME, 'errorlevel', 2089, 20, 2089, 30),
woosh.Token(woosh.OP, '>', 2089, 31, 2089, 32),
woosh.Token(woosh.NUMBER, '1', 2089, 33, 2089, 34),
woosh.Token(woosh.OP, ':', 2089, 34, 2089, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 2089, 35, 2090, 0),
woosh.Token(woosh.INDENT, ' ', 2090, 0, 2090, 16),
woosh.Token(woosh.NAME, 'raise', 2090, 16, 2090, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 2090, 21, 2091, 0),
woosh.Token(woosh.DEDENT, ' ', 2091, 0, 2091, 12),
woosh.Token(woosh.NAME, 'else', 2091, 12, 2091, 16),
woosh.Token(woosh.OP, ':', 2091, 16, 2091, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 2091, 17, 2092, 0),
woosh.Token(woosh.INDENT, ' ', 2092, 0, 2092, 16),
woosh.Token(woosh.NAME, 'self', 2092, 16, 2092, 20),
woosh.Token(woosh.OP, '.', 2092, 20, 2092, 21),
woosh.Token(woosh.NAME, '_dbg', 2092, 21, 2092, 25),
woosh.Token(woosh.OP, '(', 2092, 25, 2092, 26),
woosh.Token(woosh.NUMBER, '1', 2092, 26, 2092, 27),
woosh.Token(woosh.OP, ',', 2092, 27, 2092, 28),
woosh.Token(woosh.STRING, '"tarfile: %s"', 2092, 29, 2092, 42),
woosh.Token(woosh.OP, '%', 2092, 43, 2092, 44),
woosh.Token(woosh.NAME, 'e', 2092, 45, 2092, 46),
woosh.Token(woosh.OP, ')', 2092, 46, 2092, 47),
woosh.Token(woosh.NEWLINE, '\r\n', 2092, 47, 2093, 0),
woosh.Token(woosh.DEDENT, ' ', 2094, 0, 2094, 4),
woosh.Token(woosh.DEDENT, '', 2094, 4, 2094, 4),
woosh.Token(woosh.DEDENT, '', 2094, 4, 2094, 4),
woosh.Token(woosh.NAME, 'def', 2094, 4, 2094, 7),
woosh.Token(woosh.NAME, 'extractfile', 2094, 8, 2094, 19),
woosh.Token(woosh.OP, '(', 2094, 19, 2094, 20),
woosh.Token(woosh.NAME, 'self', 2094, 20, 2094, 24),
woosh.Token(woosh.OP, ',', 2094, 24, 2094, 25),
woosh.Token(woosh.NAME, 'member', 2094, 26, 2094, 32),
woosh.Token(woosh.OP, ')', 2094, 32, 2094, 33),
woosh.Token(woosh.OP, ':', 2094, 33, 2094, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 2094, 34, 2095, 0),
woosh.Token(woosh.INDENT, ' ', 2095, 0, 2095, 8),
woosh.Token(woosh.STRING, '"""Extract a member from the archive as a file object. `member\' may be\r\n a filename or a TarInfo object. If `member\' is a regular file or a\r\n link, an io.BufferedReader object is returned. Otherwise, None is\r\n returned.\r\n """', 2095, 8, 2099, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 2099, 11, 2100, 0),
woosh.Token(woosh.NAME, 'self', 2100, 8, 2100, 12),
woosh.Token(woosh.OP, '.', 2100, 12, 2100, 13),
woosh.Token(woosh.NAME, '_check', 2100, 13, 2100, 19),
woosh.Token(woosh.OP, '(', 2100, 19, 2100, 20),
woosh.Token(woosh.STRING, '"r"', 2100, 20, 2100, 23),
woosh.Token(woosh.OP, ')', 2100, 23, 2100, 24),
woosh.Token(woosh.NEWLINE, '\r\n', 2100, 24, 2101, 0),
woosh.Token(woosh.NAME, 'if', 2102, 8, 2102, 10),
woosh.Token(woosh.NAME, 'isinstance', 2102, 11, 2102, 21),
woosh.Token(woosh.OP, '(', 2102, 21, 2102, 22),
woosh.Token(woosh.NAME, 'member', 2102, 22, 2102, 28),
woosh.Token(woosh.OP, ',', 2102, 28, 2102, 29),
woosh.Token(woosh.NAME, 'str', 2102, 30, 2102, 33),
woosh.Token(woosh.OP, ')', 2102, 33, 2102, 34),
woosh.Token(woosh.OP, ':', 2102, 34, 2102, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 2102, 35, 2103, 0),
woosh.Token(woosh.INDENT, ' ', 2103, 0, 2103, 12),
woosh.Token(woosh.NAME, 'tarinfo', 2103, 12, 2103, 19),
woosh.Token(woosh.OP, '=', 2103, 20, 2103, 21),
woosh.Token(woosh.NAME, 'self', 2103, 22, 2103, 26),
woosh.Token(woosh.OP, '.', 2103, 26, 2103, 27),
woosh.Token(woosh.NAME, 'getmember', 2103, 27, 2103, 36),
woosh.Token(woosh.OP, '(', 2103, 36, 2103, 37),
woosh.Token(woosh.NAME, 'member', 2103, 37, 2103, 43),
woosh.Token(woosh.OP, ')', 2103, 43, 2103, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 2103, 44, 2104, 0),
woosh.Token(woosh.DEDENT, ' ', 2104, 0, 2104, 8),
woosh.Token(woosh.NAME, 'else', 2104, 8, 2104, 12),
woosh.Token(woosh.OP, ':', 2104, 12, 2104, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 2104, 13, 2105, 0),
woosh.Token(woosh.INDENT, ' ', 2105, 0, 2105, 12),
woosh.Token(woosh.NAME, 'tarinfo', 2105, 12, 2105, 19),
woosh.Token(woosh.OP, '=', 2105, 20, 2105, 21),
woosh.Token(woosh.NAME, 'member', 2105, 22, 2105, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 2105, 28, 2106, 0),
woosh.Token(woosh.DEDENT, ' ', 2107, 0, 2107, 8),
woosh.Token(woosh.NAME, 'if', 2107, 8, 2107, 10),
woosh.Token(woosh.NAME, 'tarinfo', 2107, 11, 2107, 18),
woosh.Token(woosh.OP, '.', 2107, 18, 2107, 19),
woosh.Token(woosh.NAME, 'isreg', 2107, 19, 2107, 24),
woosh.Token(woosh.OP, '(', 2107, 24, 2107, 25),
woosh.Token(woosh.OP, ')', 2107, 25, 2107, 26),
woosh.Token(woosh.NAME, 'or', 2107, 27, 2107, 29),
woosh.Token(woosh.NAME, 'tarinfo', 2107, 30, 2107, 37),
woosh.Token(woosh.OP, '.', 2107, 37, 2107, 38),
woosh.Token(woosh.NAME, 'type', 2107, 38, 2107, 42),
woosh.Token(woosh.NAME, 'not', 2107, 43, 2107, 46),
woosh.Token(woosh.NAME, 'in', 2107, 47, 2107, 49),
woosh.Token(woosh.NAME, 'SUPPORTED_TYPES', 2107, 50, 2107, 65),
woosh.Token(woosh.OP, ':', 2107, 65, 2107, 66),
woosh.Token(woosh.NEWLINE, '\r\n', 2107, 66, 2108, 0),
woosh.Token(woosh.COMMENT, '# Members with unknown types are treated as regular files.', 2108, 12, 2108, 70),
woosh.Token(woosh.INDENT, ' ', 2109, 0, 2109, 12),
woosh.Token(woosh.NAME, 'return', 2109, 12, 2109, 18),
woosh.Token(woosh.NAME, 'self', 2109, 19, 2109, 23),
woosh.Token(woosh.OP, '.', 2109, 23, 2109, 24),
woosh.Token(woosh.NAME, 'fileobject', 2109, 24, 2109, 34),
woosh.Token(woosh.OP, '(', 2109, 34, 2109, 35),
woosh.Token(woosh.NAME, 'self', 2109, 35, 2109, 39),
woosh.Token(woosh.OP, ',', 2109, 39, 2109, 40),
woosh.Token(woosh.NAME, 'tarinfo', 2109, 41, 2109, 48),
woosh.Token(woosh.OP, ')', 2109, 48, 2109, 49),
woosh.Token(woosh.NEWLINE, '\r\n', 2109, 49, 2110, 0),
woosh.Token(woosh.DEDENT, ' ', 2111, 0, 2111, 8),
woosh.Token(woosh.NAME, 'elif', 2111, 8, 2111, 12),
woosh.Token(woosh.NAME, 'tarinfo', 2111, 13, 2111, 20),
woosh.Token(woosh.OP, '.', 2111, 20, 2111, 21),
woosh.Token(woosh.NAME, 'islnk', 2111, 21, 2111, 26),
woosh.Token(woosh.OP, '(', 2111, 26, 2111, 27),
woosh.Token(woosh.OP, ')', 2111, 27, 2111, 28),
woosh.Token(woosh.NAME, 'or', 2111, 29, 2111, 31),
woosh.Token(woosh.NAME, 'tarinfo', 2111, 32, 2111, 39),
woosh.Token(woosh.OP, '.', 2111, 39, 2111, 40),
woosh.Token(woosh.NAME, 'issym', 2111, 40, 2111, 45),
woosh.Token(woosh.OP, '(', 2111, 45, 2111, 46),
woosh.Token(woosh.OP, ')', 2111, 46, 2111, 47),
woosh.Token(woosh.OP, ':', 2111, 47, 2111, 48),
woosh.Token(woosh.NEWLINE, '\r\n', 2111, 48, 2112, 0),
woosh.Token(woosh.INDENT, ' ', 2112, 0, 2112, 12),
woosh.Token(woosh.NAME, 'if', 2112, 12, 2112, 14),
woosh.Token(woosh.NAME, 'isinstance', 2112, 15, 2112, 25),
woosh.Token(woosh.OP, '(', 2112, 25, 2112, 26),
woosh.Token(woosh.NAME, 'self', 2112, 26, 2112, 30),
woosh.Token(woosh.OP, '.', 2112, 30, 2112, 31),
woosh.Token(woosh.NAME, 'fileobj', 2112, 31, 2112, 38),
woosh.Token(woosh.OP, ',', 2112, 38, 2112, 39),
woosh.Token(woosh.NAME, '_Stream', 2112, 40, 2112, 47),
woosh.Token(woosh.OP, ')', 2112, 47, 2112, 48),
woosh.Token(woosh.OP, ':', 2112, 48, 2112, 49),
woosh.Token(woosh.NEWLINE, '\r\n', 2112, 49, 2113, 0),
woosh.Token(woosh.COMMENT, '# A small but ugly workaround for the case that someone tries', 2113, 16, 2113, 77),
woosh.Token(woosh.COMMENT, '# to extract a (sym)link as a file-object from a non-seekable', 2114, 16, 2114, 77),
woosh.Token(woosh.COMMENT, '# stream of tar blocks.', 2115, 16, 2115, 39),
woosh.Token(woosh.INDENT, ' ', 2116, 0, 2116, 16),
woosh.Token(woosh.NAME, 'raise', 2116, 16, 2116, 21),
woosh.Token(woosh.NAME, 'StreamError', 2116, 22, 2116, 33),
woosh.Token(woosh.OP, '(', 2116, 33, 2116, 34),
woosh.Token(woosh.STRING, '"cannot extract (sym)link as file object"', 2116, 34, 2116, 75),
woosh.Token(woosh.OP, ')', 2116, 75, 2116, 76),
woosh.Token(woosh.NEWLINE, '\r\n', 2116, 76, 2117, 0),
woosh.Token(woosh.DEDENT, ' ', 2117, 0, 2117, 12),
woosh.Token(woosh.NAME, 'else', 2117, 12, 2117, 16),
woosh.Token(woosh.OP, ':', 2117, 16, 2117, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 2117, 17, 2118, 0),
woosh.Token(woosh.COMMENT, "# A (sym)link's file object is its target's file object.", 2118, 16, 2118, 72),
woosh.Token(woosh.INDENT, ' ', 2119, 0, 2119, 16),
woosh.Token(woosh.NAME, 'return', 2119, 16, 2119, 22),
woosh.Token(woosh.NAME, 'self', 2119, 23, 2119, 27),
woosh.Token(woosh.OP, '.', 2119, 27, 2119, 28),
woosh.Token(woosh.NAME, 'extractfile', 2119, 28, 2119, 39),
woosh.Token(woosh.OP, '(', 2119, 39, 2119, 40),
woosh.Token(woosh.NAME, 'self', 2119, 40, 2119, 44),
woosh.Token(woosh.OP, '.', 2119, 44, 2119, 45),
woosh.Token(woosh.NAME, '_find_link_target', 2119, 45, 2119, 62),
woosh.Token(woosh.OP, '(', 2119, 62, 2119, 63),
woosh.Token(woosh.NAME, 'tarinfo', 2119, 63, 2119, 70),
woosh.Token(woosh.OP, ')', 2119, 70, 2119, 71),
woosh.Token(woosh.OP, ')', 2119, 71, 2119, 72),
woosh.Token(woosh.NEWLINE, '\r\n', 2119, 72, 2120, 0),
woosh.Token(woosh.DEDENT, ' ', 2120, 0, 2120, 8),
woosh.Token(woosh.DEDENT, '', 2120, 8, 2120, 8),
woosh.Token(woosh.NAME, 'else', 2120, 8, 2120, 12),
woosh.Token(woosh.OP, ':', 2120, 12, 2120, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 2120, 13, 2121, 0),
woosh.Token(woosh.COMMENT, "# If there's no data associated with the member (directory, chrdev,", 2121, 12, 2121, 79),
woosh.Token(woosh.COMMENT, '# blkdev, etc.), return None instead of a file object.', 2122, 12, 2122, 66),
woosh.Token(woosh.INDENT, ' ', 2123, 0, 2123, 12),
woosh.Token(woosh.NAME, 'return', 2123, 12, 2123, 18),
woosh.Token(woosh.NAME, 'None', 2123, 19, 2123, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 2123, 23, 2124, 0),
woosh.Token(woosh.DEDENT, ' ', 2125, 0, 2125, 4),
woosh.Token(woosh.DEDENT, '', 2125, 4, 2125, 4),
woosh.Token(woosh.NAME, 'def', 2125, 4, 2125, 7),
woosh.Token(woosh.NAME, '_extract_member', 2125, 8, 2125, 23),
woosh.Token(woosh.OP, '(', 2125, 23, 2125, 24),
woosh.Token(woosh.NAME, 'self', 2125, 24, 2125, 28),
woosh.Token(woosh.OP, ',', 2125, 28, 2125, 29),
woosh.Token(woosh.NAME, 'tarinfo', 2125, 30, 2125, 37),
woosh.Token(woosh.OP, ',', 2125, 37, 2125, 38),
woosh.Token(woosh.NAME, 'targetpath', 2125, 39, 2125, 49),
woosh.Token(woosh.OP, ',', 2125, 49, 2125, 50),
woosh.Token(woosh.NAME, 'set_attrs', 2125, 51, 2125, 60),
woosh.Token(woosh.OP, '=', 2125, 60, 2125, 61),
woosh.Token(woosh.NAME, 'True', 2125, 61, 2125, 65),
woosh.Token(woosh.OP, ',', 2125, 65, 2125, 66),
woosh.Token(woosh.NAME, 'numeric_owner', 2126, 24, 2126, 37),
woosh.Token(woosh.OP, '=', 2126, 37, 2126, 38),
woosh.Token(woosh.NAME, 'False', 2126, 38, 2126, 43),
woosh.Token(woosh.OP, ')', 2126, 43, 2126, 44),
woosh.Token(woosh.OP, ':', 2126, 44, 2126, 45),
woosh.Token(woosh.NEWLINE, '\r\n', 2126, 45, 2127, 0),
woosh.Token(woosh.INDENT, ' ', 2127, 0, 2127, 8),
woosh.Token(woosh.STRING, '"""Extract the TarInfo object tarinfo to a physical\r\n file called targetpath.\r\n """', 2127, 8, 2129, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 2129, 11, 2130, 0),
woosh.Token(woosh.COMMENT, '# Fetch the TarInfo object for the given name', 2130, 8, 2130, 53),
woosh.Token(woosh.COMMENT, '# and build the destination pathname, replacing', 2131, 8, 2131, 55),
woosh.Token(woosh.COMMENT, '# forward slashes to platform specific separators.', 2132, 8, 2132, 58),
woosh.Token(woosh.NAME, 'targetpath', 2133, 8, 2133, 18),
woosh.Token(woosh.OP, '=', 2133, 19, 2133, 20),
woosh.Token(woosh.NAME, 'targetpath', 2133, 21, 2133, 31),
woosh.Token(woosh.OP, '.', 2133, 31, 2133, 32),
woosh.Token(woosh.NAME, 'rstrip', 2133, 32, 2133, 38),
woosh.Token(woosh.OP, '(', 2133, 38, 2133, 39),
woosh.Token(woosh.STRING, '"/"', 2133, 39, 2133, 42),
woosh.Token(woosh.OP, ')', 2133, 42, 2133, 43),
woosh.Token(woosh.NEWLINE, '\r\n', 2133, 43, 2134, 0),
woosh.Token(woosh.NAME, 'targetpath', 2134, 8, 2134, 18),
woosh.Token(woosh.OP, '=', 2134, 19, 2134, 20),
woosh.Token(woosh.NAME, 'targetpath', 2134, 21, 2134, 31),
woosh.Token(woosh.OP, '.', 2134, 31, 2134, 32),
woosh.Token(woosh.NAME, 'replace', 2134, 32, 2134, 39),
woosh.Token(woosh.OP, '(', 2134, 39, 2134, 40),
woosh.Token(woosh.STRING, '"/"', 2134, 40, 2134, 43),
woosh.Token(woosh.OP, ',', 2134, 43, 2134, 44),
woosh.Token(woosh.NAME, 'os', 2134, 45, 2134, 47),
woosh.Token(woosh.OP, '.', 2134, 47, 2134, 48),
woosh.Token(woosh.NAME, 'sep', 2134, 48, 2134, 51),
woosh.Token(woosh.OP, ')', 2134, 51, 2134, 52),
woosh.Token(woosh.NEWLINE, '\r\n', 2134, 52, 2135, 0),
woosh.Token(woosh.COMMENT, '# Create all upper directories.', 2136, 8, 2136, 39),
woosh.Token(woosh.NAME, 'upperdirs', 2137, 8, 2137, 17),
woosh.Token(woosh.OP, '=', 2137, 18, 2137, 19),
woosh.Token(woosh.NAME, 'os', 2137, 20, 2137, 22),
woosh.Token(woosh.OP, '.', 2137, 22, 2137, 23),
woosh.Token(woosh.NAME, 'path', 2137, 23, 2137, 27),
woosh.Token(woosh.OP, '.', 2137, 27, 2137, 28),
woosh.Token(woosh.NAME, 'dirname', 2137, 28, 2137, 35),
woosh.Token(woosh.OP, '(', 2137, 35, 2137, 36),
woosh.Token(woosh.NAME, 'targetpath', 2137, 36, 2137, 46),
woosh.Token(woosh.OP, ')', 2137, 46, 2137, 47),
woosh.Token(woosh.NEWLINE, '\r\n', 2137, 47, 2138, 0),
woosh.Token(woosh.NAME, 'if', 2138, 8, 2138, 10),
woosh.Token(woosh.NAME, 'upperdirs', 2138, 11, 2138, 20),
woosh.Token(woosh.NAME, 'and', 2138, 21, 2138, 24),
woosh.Token(woosh.NAME, 'not', 2138, 25, 2138, 28),
woosh.Token(woosh.NAME, 'os', 2138, 29, 2138, 31),
woosh.Token(woosh.OP, '.', 2138, 31, 2138, 32),
woosh.Token(woosh.NAME, 'path', 2138, 32, 2138, 36),
woosh.Token(woosh.OP, '.', 2138, 36, 2138, 37),
woosh.Token(woosh.NAME, 'exists', 2138, 37, 2138, 43),
woosh.Token(woosh.OP, '(', 2138, 43, 2138, 44),
woosh.Token(woosh.NAME, 'upperdirs', 2138, 44, 2138, 53),
woosh.Token(woosh.OP, ')', 2138, 53, 2138, 54),
woosh.Token(woosh.OP, ':', 2138, 54, 2138, 55),
woosh.Token(woosh.NEWLINE, '\r\n', 2138, 55, 2139, 0),
woosh.Token(woosh.COMMENT, '# Create directories that are not part of the archive with', 2139, 12, 2139, 70),
woosh.Token(woosh.COMMENT, '# default permissions.', 2140, 12, 2140, 34),
woosh.Token(woosh.INDENT, ' ', 2141, 0, 2141, 12),
woosh.Token(woosh.NAME, 'os', 2141, 12, 2141, 14),
woosh.Token(woosh.OP, '.', 2141, 14, 2141, 15),
woosh.Token(woosh.NAME, 'makedirs', 2141, 15, 2141, 23),
woosh.Token(woosh.OP, '(', 2141, 23, 2141, 24),
woosh.Token(woosh.NAME, 'upperdirs', 2141, 24, 2141, 33),
woosh.Token(woosh.OP, ')', 2141, 33, 2141, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 2141, 34, 2142, 0),
woosh.Token(woosh.DEDENT, ' ', 2143, 0, 2143, 8),
woosh.Token(woosh.NAME, 'if', 2143, 8, 2143, 10),
woosh.Token(woosh.NAME, 'tarinfo', 2143, 11, 2143, 18),
woosh.Token(woosh.OP, '.', 2143, 18, 2143, 19),
woosh.Token(woosh.NAME, 'islnk', 2143, 19, 2143, 24),
woosh.Token(woosh.OP, '(', 2143, 24, 2143, 25),
woosh.Token(woosh.OP, ')', 2143, 25, 2143, 26),
woosh.Token(woosh.NAME, 'or', 2143, 27, 2143, 29),
woosh.Token(woosh.NAME, 'tarinfo', 2143, 30, 2143, 37),
woosh.Token(woosh.OP, '.', 2143, 37, 2143, 38),
woosh.Token(woosh.NAME, 'issym', 2143, 38, 2143, 43),
woosh.Token(woosh.OP, '(', 2143, 43, 2143, 44),
woosh.Token(woosh.OP, ')', 2143, 44, 2143, 45),
woosh.Token(woosh.OP, ':', 2143, 45, 2143, 46),
woosh.Token(woosh.NEWLINE, '\r\n', 2143, 46, 2144, 0),
woosh.Token(woosh.INDENT, ' ', 2144, 0, 2144, 12),
woosh.Token(woosh.NAME, 'self', 2144, 12, 2144, 16),
woosh.Token(woosh.OP, '.', 2144, 16, 2144, 17),
woosh.Token(woosh.NAME, '_dbg', 2144, 17, 2144, 21),
woosh.Token(woosh.OP, '(', 2144, 21, 2144, 22),
woosh.Token(woosh.NUMBER, '1', 2144, 22, 2144, 23),
woosh.Token(woosh.OP, ',', 2144, 23, 2144, 24),
woosh.Token(woosh.STRING, '"%s -> %s"', 2144, 25, 2144, 35),
woosh.Token(woosh.OP, '%', 2144, 36, 2144, 37),
woosh.Token(woosh.OP, '(', 2144, 38, 2144, 39),
woosh.Token(woosh.NAME, 'tarinfo', 2144, 39, 2144, 46),
woosh.Token(woosh.OP, '.', 2144, 46, 2144, 47),
woosh.Token(woosh.NAME, 'name', 2144, 47, 2144, 51),
woosh.Token(woosh.OP, ',', 2144, 51, 2144, 52),
woosh.Token(woosh.NAME, 'tarinfo', 2144, 53, 2144, 60),
woosh.Token(woosh.OP, '.', 2144, 60, 2144, 61),
woosh.Token(woosh.NAME, 'linkname', 2144, 61, 2144, 69),
woosh.Token(woosh.OP, ')', 2144, 69, 2144, 70),
woosh.Token(woosh.OP, ')', 2144, 70, 2144, 71),
woosh.Token(woosh.NEWLINE, '\r\n', 2144, 71, 2145, 0),
woosh.Token(woosh.DEDENT, ' ', 2145, 0, 2145, 8),
woosh.Token(woosh.NAME, 'else', 2145, 8, 2145, 12),
woosh.Token(woosh.OP, ':', 2145, 12, 2145, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 2145, 13, 2146, 0),
woosh.Token(woosh.INDENT, ' ', 2146, 0, 2146, 12),
woosh.Token(woosh.NAME, 'self', 2146, 12, 2146, 16),
woosh.Token(woosh.OP, '.', 2146, 16, 2146, 17),
woosh.Token(woosh.NAME, '_dbg', 2146, 17, 2146, 21),
woosh.Token(woosh.OP, '(', 2146, 21, 2146, 22),
woosh.Token(woosh.NUMBER, '1', 2146, 22, 2146, 23),
woosh.Token(woosh.OP, ',', 2146, 23, 2146, 24),
woosh.Token(woosh.NAME, 'tarinfo', 2146, 25, 2146, 32),
woosh.Token(woosh.OP, '.', 2146, 32, 2146, 33),
woosh.Token(woosh.NAME, 'name', 2146, 33, 2146, 37),
woosh.Token(woosh.OP, ')', 2146, 37, 2146, 38),
woosh.Token(woosh.NEWLINE, '\r\n', 2146, 38, 2147, 0),
woosh.Token(woosh.DEDENT, ' ', 2148, 0, 2148, 8),
woosh.Token(woosh.NAME, 'if', 2148, 8, 2148, 10),
woosh.Token(woosh.NAME, 'tarinfo', 2148, 11, 2148, 18),
woosh.Token(woosh.OP, '.', 2148, 18, 2148, 19),
woosh.Token(woosh.NAME, 'isreg', 2148, 19, 2148, 24),
woosh.Token(woosh.OP, '(', 2148, 24, 2148, 25),
woosh.Token(woosh.OP, ')', 2148, 25, 2148, 26),
woosh.Token(woosh.OP, ':', 2148, 26, 2148, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 2148, 27, 2149, 0),
woosh.Token(woosh.INDENT, ' ', 2149, 0, 2149, 12),
woosh.Token(woosh.NAME, 'self', 2149, 12, 2149, 16),
woosh.Token(woosh.OP, '.', 2149, 16, 2149, 17),
woosh.Token(woosh.NAME, 'makefile', 2149, 17, 2149, 25),
woosh.Token(woosh.OP, '(', 2149, 25, 2149, 26),
woosh.Token(woosh.NAME, 'tarinfo', 2149, 26, 2149, 33),
woosh.Token(woosh.OP, ',', 2149, 33, 2149, 34),
woosh.Token(woosh.NAME, 'targetpath', 2149, 35, 2149, 45),
woosh.Token(woosh.OP, ')', 2149, 45, 2149, 46),
woosh.Token(woosh.NEWLINE, '\r\n', 2149, 46, 2150, 0),
woosh.Token(woosh.DEDENT, ' ', 2150, 0, 2150, 8),
woosh.Token(woosh.NAME, 'elif', 2150, 8, 2150, 12),
woosh.Token(woosh.NAME, 'tarinfo', 2150, 13, 2150, 20),
woosh.Token(woosh.OP, '.', 2150, 20, 2150, 21),
woosh.Token(woosh.NAME, 'isdir', 2150, 21, 2150, 26),
woosh.Token(woosh.OP, '(', 2150, 26, 2150, 27),
woosh.Token(woosh.OP, ')', 2150, 27, 2150, 28),
woosh.Token(woosh.OP, ':', 2150, 28, 2150, 29),
woosh.Token(woosh.NEWLINE, '\r\n', 2150, 29, 2151, 0),
woosh.Token(woosh.INDENT, ' ', 2151, 0, 2151, 12),
woosh.Token(woosh.NAME, 'self', 2151, 12, 2151, 16),
woosh.Token(woosh.OP, '.', 2151, 16, 2151, 17),
woosh.Token(woosh.NAME, 'makedir', 2151, 17, 2151, 24),
woosh.Token(woosh.OP, '(', 2151, 24, 2151, 25),
woosh.Token(woosh.NAME, 'tarinfo', 2151, 25, 2151, 32),
woosh.Token(woosh.OP, ',', 2151, 32, 2151, 33),
woosh.Token(woosh.NAME, 'targetpath', 2151, 34, 2151, 44),
woosh.Token(woosh.OP, ')', 2151, 44, 2151, 45),
woosh.Token(woosh.NEWLINE, '\r\n', 2151, 45, 2152, 0),
woosh.Token(woosh.DEDENT, ' ', 2152, 0, 2152, 8),
woosh.Token(woosh.NAME, 'elif', 2152, 8, 2152, 12),
woosh.Token(woosh.NAME, 'tarinfo', 2152, 13, 2152, 20),
woosh.Token(woosh.OP, '.', 2152, 20, 2152, 21),
woosh.Token(woosh.NAME, 'isfifo', 2152, 21, 2152, 27),
woosh.Token(woosh.OP, '(', 2152, 27, 2152, 28),
woosh.Token(woosh.OP, ')', 2152, 28, 2152, 29),
woosh.Token(woosh.OP, ':', 2152, 29, 2152, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 2152, 30, 2153, 0),
woosh.Token(woosh.INDENT, ' ', 2153, 0, 2153, 12),
woosh.Token(woosh.NAME, 'self', 2153, 12, 2153, 16),
woosh.Token(woosh.OP, '.', 2153, 16, 2153, 17),
woosh.Token(woosh.NAME, 'makefifo', 2153, 17, 2153, 25),
woosh.Token(woosh.OP, '(', 2153, 25, 2153, 26),
woosh.Token(woosh.NAME, 'tarinfo', 2153, 26, 2153, 33),
woosh.Token(woosh.OP, ',', 2153, 33, 2153, 34),
woosh.Token(woosh.NAME, 'targetpath', 2153, 35, 2153, 45),
woosh.Token(woosh.OP, ')', 2153, 45, 2153, 46),
woosh.Token(woosh.NEWLINE, '\r\n', 2153, 46, 2154, 0),
woosh.Token(woosh.DEDENT, ' ', 2154, 0, 2154, 8),
woosh.Token(woosh.NAME, 'elif', 2154, 8, 2154, 12),
woosh.Token(woosh.NAME, 'tarinfo', 2154, 13, 2154, 20),
woosh.Token(woosh.OP, '.', 2154, 20, 2154, 21),
woosh.Token(woosh.NAME, 'ischr', 2154, 21, 2154, 26),
woosh.Token(woosh.OP, '(', 2154, 26, 2154, 27),
woosh.Token(woosh.OP, ')', 2154, 27, 2154, 28),
woosh.Token(woosh.NAME, 'or', 2154, 29, 2154, 31),
woosh.Token(woosh.NAME, 'tarinfo', 2154, 32, 2154, 39),
woosh.Token(woosh.OP, '.', 2154, 39, 2154, 40),
woosh.Token(woosh.NAME, 'isblk', 2154, 40, 2154, 45),
woosh.Token(woosh.OP, '(', 2154, 45, 2154, 46),
woosh.Token(woosh.OP, ')', 2154, 46, 2154, 47),
woosh.Token(woosh.OP, ':', 2154, 47, 2154, 48),
woosh.Token(woosh.NEWLINE, '\r\n', 2154, 48, 2155, 0),
woosh.Token(woosh.INDENT, ' ', 2155, 0, 2155, 12),
woosh.Token(woosh.NAME, 'self', 2155, 12, 2155, 16),
woosh.Token(woosh.OP, '.', 2155, 16, 2155, 17),
woosh.Token(woosh.NAME, 'makedev', 2155, 17, 2155, 24),
woosh.Token(woosh.OP, '(', 2155, 24, 2155, 25),
woosh.Token(woosh.NAME, 'tarinfo', 2155, 25, 2155, 32),
woosh.Token(woosh.OP, ',', 2155, 32, 2155, 33),
woosh.Token(woosh.NAME, 'targetpath', 2155, 34, 2155, 44),
woosh.Token(woosh.OP, ')', 2155, 44, 2155, 45),
woosh.Token(woosh.NEWLINE, '\r\n', 2155, 45, 2156, 0),
woosh.Token(woosh.DEDENT, ' ', 2156, 0, 2156, 8),
woosh.Token(woosh.NAME, 'elif', 2156, 8, 2156, 12),
woosh.Token(woosh.NAME, 'tarinfo', 2156, 13, 2156, 20),
woosh.Token(woosh.OP, '.', 2156, 20, 2156, 21),
woosh.Token(woosh.NAME, 'islnk', 2156, 21, 2156, 26),
woosh.Token(woosh.OP, '(', 2156, 26, 2156, 27),
woosh.Token(woosh.OP, ')', 2156, 27, 2156, 28),
woosh.Token(woosh.NAME, 'or', 2156, 29, 2156, 31),
woosh.Token(woosh.NAME, 'tarinfo', 2156, 32, 2156, 39),
woosh.Token(woosh.OP, '.', 2156, 39, 2156, 40),
woosh.Token(woosh.NAME, 'issym', 2156, 40, 2156, 45),
woosh.Token(woosh.OP, '(', 2156, 45, 2156, 46),
woosh.Token(woosh.OP, ')', 2156, 46, 2156, 47),
woosh.Token(woosh.OP, ':', 2156, 47, 2156, 48),
woosh.Token(woosh.NEWLINE, '\r\n', 2156, 48, 2157, 0),
woosh.Token(woosh.INDENT, ' ', 2157, 0, 2157, 12),
woosh.Token(woosh.NAME, 'self', 2157, 12, 2157, 16),
woosh.Token(woosh.OP, '.', 2157, 16, 2157, 17),
woosh.Token(woosh.NAME, 'makelink', 2157, 17, 2157, 25),
woosh.Token(woosh.OP, '(', 2157, 25, 2157, 26),
woosh.Token(woosh.NAME, 'tarinfo', 2157, 26, 2157, 33),
woosh.Token(woosh.OP, ',', 2157, 33, 2157, 34),
woosh.Token(woosh.NAME, 'targetpath', 2157, 35, 2157, 45),
woosh.Token(woosh.OP, ')', 2157, 45, 2157, 46),
woosh.Token(woosh.NEWLINE, '\r\n', 2157, 46, 2158, 0),
woosh.Token(woosh.DEDENT, ' ', 2158, 0, 2158, 8),
woosh.Token(woosh.NAME, 'elif', 2158, 8, 2158, 12),
woosh.Token(woosh.NAME, 'tarinfo', 2158, 13, 2158, 20),
woosh.Token(woosh.OP, '.', 2158, 20, 2158, 21),
woosh.Token(woosh.NAME, 'type', 2158, 21, 2158, 25),
woosh.Token(woosh.NAME, 'not', 2158, 26, 2158, 29),
woosh.Token(woosh.NAME, 'in', 2158, 30, 2158, 32),
woosh.Token(woosh.NAME, 'SUPPORTED_TYPES', 2158, 33, 2158, 48),
woosh.Token(woosh.OP, ':', 2158, 48, 2158, 49),
woosh.Token(woosh.NEWLINE, '\r\n', 2158, 49, 2159, 0),
woosh.Token(woosh.INDENT, ' ', 2159, 0, 2159, 12),
woosh.Token(woosh.NAME, 'self', 2159, 12, 2159, 16),
woosh.Token(woosh.OP, '.', 2159, 16, 2159, 17),
woosh.Token(woosh.NAME, 'makeunknown', 2159, 17, 2159, 28),
woosh.Token(woosh.OP, '(', 2159, 28, 2159, 29),
woosh.Token(woosh.NAME, 'tarinfo', 2159, 29, 2159, 36),
woosh.Token(woosh.OP, ',', 2159, 36, 2159, 37),
woosh.Token(woosh.NAME, 'targetpath', 2159, 38, 2159, 48),
woosh.Token(woosh.OP, ')', 2159, 48, 2159, 49),
woosh.Token(woosh.NEWLINE, '\r\n', 2159, 49, 2160, 0),
woosh.Token(woosh.DEDENT, ' ', 2160, 0, 2160, 8),
woosh.Token(woosh.NAME, 'else', 2160, 8, 2160, 12),
woosh.Token(woosh.OP, ':', 2160, 12, 2160, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 2160, 13, 2161, 0),
woosh.Token(woosh.INDENT, ' ', 2161, 0, 2161, 12),
woosh.Token(woosh.NAME, 'self', 2161, 12, 2161, 16),
woosh.Token(woosh.OP, '.', 2161, 16, 2161, 17),
woosh.Token(woosh.NAME, 'makefile', 2161, 17, 2161, 25),
woosh.Token(woosh.OP, '(', 2161, 25, 2161, 26),
woosh.Token(woosh.NAME, 'tarinfo', 2161, 26, 2161, 33),
woosh.Token(woosh.OP, ',', 2161, 33, 2161, 34),
woosh.Token(woosh.NAME, 'targetpath', 2161, 35, 2161, 45),
woosh.Token(woosh.OP, ')', 2161, 45, 2161, 46),
woosh.Token(woosh.NEWLINE, '\r\n', 2161, 46, 2162, 0),
woosh.Token(woosh.DEDENT, ' ', 2163, 0, 2163, 8),
woosh.Token(woosh.NAME, 'if', 2163, 8, 2163, 10),
woosh.Token(woosh.NAME, 'set_attrs', 2163, 11, 2163, 20),
woosh.Token(woosh.OP, ':', 2163, 20, 2163, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 2163, 21, 2164, 0),
woosh.Token(woosh.INDENT, ' ', 2164, 0, 2164, 12),
woosh.Token(woosh.NAME, 'self', 2164, 12, 2164, 16),
woosh.Token(woosh.OP, '.', 2164, 16, 2164, 17),
woosh.Token(woosh.NAME, 'chown', 2164, 17, 2164, 22),
woosh.Token(woosh.OP, '(', 2164, 22, 2164, 23),
woosh.Token(woosh.NAME, 'tarinfo', 2164, 23, 2164, 30),
woosh.Token(woosh.OP, ',', 2164, 30, 2164, 31),
woosh.Token(woosh.NAME, 'targetpath', 2164, 32, 2164, 42),
woosh.Token(woosh.OP, ',', 2164, 42, 2164, 43),
woosh.Token(woosh.NAME, 'numeric_owner', 2164, 44, 2164, 57),
woosh.Token(woosh.OP, ')', 2164, 57, 2164, 58),
woosh.Token(woosh.NEWLINE, '\r\n', 2164, 58, 2165, 0),
woosh.Token(woosh.NAME, 'if', 2165, 12, 2165, 14),
woosh.Token(woosh.NAME, 'not', 2165, 15, 2165, 18),
woosh.Token(woosh.NAME, 'tarinfo', 2165, 19, 2165, 26),
woosh.Token(woosh.OP, '.', 2165, 26, 2165, 27),
woosh.Token(woosh.NAME, 'issym', 2165, 27, 2165, 32),
woosh.Token(woosh.OP, '(', 2165, 32, 2165, 33),
woosh.Token(woosh.OP, ')', 2165, 33, 2165, 34),
woosh.Token(woosh.OP, ':', 2165, 34, 2165, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 2165, 35, 2166, 0),
woosh.Token(woosh.INDENT, ' ', 2166, 0, 2166, 16),
woosh.Token(woosh.NAME, 'self', 2166, 16, 2166, 20),
woosh.Token(woosh.OP, '.', 2166, 20, 2166, 21),
woosh.Token(woosh.NAME, 'chmod', 2166, 21, 2166, 26),
woosh.Token(woosh.OP, '(', 2166, 26, 2166, 27),
woosh.Token(woosh.NAME, 'tarinfo', 2166, 27, 2166, 34),
woosh.Token(woosh.OP, ',', 2166, 34, 2166, 35),
woosh.Token(woosh.NAME, 'targetpath', 2166, 36, 2166, 46),
woosh.Token(woosh.OP, ')', 2166, 46, 2166, 47),
woosh.Token(woosh.NEWLINE, '\r\n', 2166, 47, 2167, 0),
woosh.Token(woosh.NAME, 'self', 2167, 16, 2167, 20),
woosh.Token(woosh.OP, '.', 2167, 20, 2167, 21),
woosh.Token(woosh.NAME, 'utime', 2167, 21, 2167, 26),
woosh.Token(woosh.OP, '(', 2167, 26, 2167, 27),
woosh.Token(woosh.NAME, 'tarinfo', 2167, 27, 2167, 34),
woosh.Token(woosh.OP, ',', 2167, 34, 2167, 35),
woosh.Token(woosh.NAME, 'targetpath', 2167, 36, 2167, 46),
woosh.Token(woosh.OP, ')', 2167, 46, 2167, 47),
woosh.Token(woosh.NEWLINE, '\r\n', 2167, 47, 2168, 0),
woosh.Token(woosh.COMMENT, '#--------------------------------------------------------------------------', 2169, 4, 2169, 79),
woosh.Token(woosh.COMMENT, '# Below are the different file methods. They are called via', 2170, 4, 2170, 63),
woosh.Token(woosh.COMMENT, '# _extract_member() when extract() is called. They can be replaced in a', 2171, 4, 2171, 75),
woosh.Token(woosh.COMMENT, '# subclass to implement other functionality.', 2172, 4, 2172, 48),
woosh.Token(woosh.DEDENT, ' ', 2174, 0, 2174, 4),
woosh.Token(woosh.DEDENT, '', 2174, 4, 2174, 4),
woosh.Token(woosh.DEDENT, '', 2174, 4, 2174, 4),
woosh.Token(woosh.NAME, 'def', 2174, 4, 2174, 7),
woosh.Token(woosh.NAME, 'makedir', 2174, 8, 2174, 15),
woosh.Token(woosh.OP, '(', 2174, 15, 2174, 16),
woosh.Token(woosh.NAME, 'self', 2174, 16, 2174, 20),
woosh.Token(woosh.OP, ',', 2174, 20, 2174, 21),
woosh.Token(woosh.NAME, 'tarinfo', 2174, 22, 2174, 29),
woosh.Token(woosh.OP, ',', 2174, 29, 2174, 30),
woosh.Token(woosh.NAME, 'targetpath', 2174, 31, 2174, 41),
woosh.Token(woosh.OP, ')', 2174, 41, 2174, 42),
woosh.Token(woosh.OP, ':', 2174, 42, 2174, 43),
woosh.Token(woosh.NEWLINE, '\r\n', 2174, 43, 2175, 0),
woosh.Token(woosh.INDENT, ' ', 2175, 0, 2175, 8),
woosh.Token(woosh.STRING, '"""Make a directory called targetpath.\r\n """', 2175, 8, 2176, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 2176, 11, 2177, 0),
woosh.Token(woosh.NAME, 'try', 2177, 8, 2177, 11),
woosh.Token(woosh.OP, ':', 2177, 11, 2177, 12),
woosh.Token(woosh.NEWLINE, '\r\n', 2177, 12, 2178, 0),
woosh.Token(woosh.COMMENT, '# Use a safe mode for the directory, the real mode is set', 2178, 12, 2178, 69),
woosh.Token(woosh.COMMENT, '# later in _extract_member().', 2179, 12, 2179, 41),
woosh.Token(woosh.INDENT, ' ', 2180, 0, 2180, 12),
woosh.Token(woosh.NAME, 'os', 2180, 12, 2180, 14),
woosh.Token(woosh.OP, '.', 2180, 14, 2180, 15),
woosh.Token(woosh.NAME, 'mkdir', 2180, 15, 2180, 20),
woosh.Token(woosh.OP, '(', 2180, 20, 2180, 21),
woosh.Token(woosh.NAME, 'targetpath', 2180, 21, 2180, 31),
woosh.Token(woosh.OP, ',', 2180, 31, 2180, 32),
woosh.Token(woosh.NUMBER, '0o700', 2180, 33, 2180, 38),
woosh.Token(woosh.OP, ')', 2180, 38, 2180, 39),
woosh.Token(woosh.NEWLINE, '\r\n', 2180, 39, 2181, 0),
woosh.Token(woosh.DEDENT, ' ', 2181, 0, 2181, 8),
woosh.Token(woosh.NAME, 'except', 2181, 8, 2181, 14),
woosh.Token(woosh.NAME, 'FileExistsError', 2181, 15, 2181, 30),
woosh.Token(woosh.OP, ':', 2181, 30, 2181, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 2181, 31, 2182, 0),
woosh.Token(woosh.INDENT, ' ', 2182, 0, 2182, 12),
woosh.Token(woosh.NAME, 'pass', 2182, 12, 2182, 16),
woosh.Token(woosh.NEWLINE, '\r\n', 2182, 16, 2183, 0),
woosh.Token(woosh.DEDENT, ' ', 2184, 0, 2184, 4),
woosh.Token(woosh.DEDENT, '', 2184, 4, 2184, 4),
woosh.Token(woosh.NAME, 'def', 2184, 4, 2184, 7),
woosh.Token(woosh.NAME, 'makefile', 2184, 8, 2184, 16),
woosh.Token(woosh.OP, '(', 2184, 16, 2184, 17),
woosh.Token(woosh.NAME, 'self', 2184, 17, 2184, 21),
woosh.Token(woosh.OP, ',', 2184, 21, 2184, 22),
woosh.Token(woosh.NAME, 'tarinfo', 2184, 23, 2184, 30),
woosh.Token(woosh.OP, ',', 2184, 30, 2184, 31),
woosh.Token(woosh.NAME, 'targetpath', 2184, 32, 2184, 42),
woosh.Token(woosh.OP, ')', 2184, 42, 2184, 43),
woosh.Token(woosh.OP, ':', 2184, 43, 2184, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 2184, 44, 2185, 0),
woosh.Token(woosh.INDENT, ' ', 2185, 0, 2185, 8),
woosh.Token(woosh.STRING, '"""Make a file called targetpath.\r\n """', 2185, 8, 2186, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 2186, 11, 2187, 0),
woosh.Token(woosh.NAME, 'source', 2187, 8, 2187, 14),
woosh.Token(woosh.OP, '=', 2187, 15, 2187, 16),
woosh.Token(woosh.NAME, 'self', 2187, 17, 2187, 21),
woosh.Token(woosh.OP, '.', 2187, 21, 2187, 22),
woosh.Token(woosh.NAME, 'fileobj', 2187, 22, 2187, 29),
woosh.Token(woosh.NEWLINE, '\r\n', 2187, 29, 2188, 0),
woosh.Token(woosh.NAME, 'source', 2188, 8, 2188, 14),
woosh.Token(woosh.OP, '.', 2188, 14, 2188, 15),
woosh.Token(woosh.NAME, 'seek', 2188, 15, 2188, 19),
woosh.Token(woosh.OP, '(', 2188, 19, 2188, 20),
woosh.Token(woosh.NAME, 'tarinfo', 2188, 20, 2188, 27),
woosh.Token(woosh.OP, '.', 2188, 27, 2188, 28),
woosh.Token(woosh.NAME, 'offset_data', 2188, 28, 2188, 39),
woosh.Token(woosh.OP, ')', 2188, 39, 2188, 40),
woosh.Token(woosh.NEWLINE, '\r\n', 2188, 40, 2189, 0),
woosh.Token(woosh.NAME, 'bufsize', 2189, 8, 2189, 15),
woosh.Token(woosh.OP, '=', 2189, 16, 2189, 17),
woosh.Token(woosh.NAME, 'self', 2189, 18, 2189, 22),
woosh.Token(woosh.OP, '.', 2189, 22, 2189, 23),
woosh.Token(woosh.NAME, 'copybufsize', 2189, 23, 2189, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 2189, 34, 2190, 0),
woosh.Token(woosh.NAME, 'with', 2190, 8, 2190, 12),
woosh.Token(woosh.NAME, 'bltn_open', 2190, 13, 2190, 22),
woosh.Token(woosh.OP, '(', 2190, 22, 2190, 23),
woosh.Token(woosh.NAME, 'targetpath', 2190, 23, 2190, 33),
woosh.Token(woosh.OP, ',', 2190, 33, 2190, 34),
woosh.Token(woosh.STRING, '"wb"', 2190, 35, 2190, 39),
woosh.Token(woosh.OP, ')', 2190, 39, 2190, 40),
woosh.Token(woosh.NAME, 'as', 2190, 41, 2190, 43),
woosh.Token(woosh.NAME, 'target', 2190, 44, 2190, 50),
woosh.Token(woosh.OP, ':', 2190, 50, 2190, 51),
woosh.Token(woosh.NEWLINE, '\r\n', 2190, 51, 2191, 0),
woosh.Token(woosh.INDENT, ' ', 2191, 0, 2191, 12),
woosh.Token(woosh.NAME, 'if', 2191, 12, 2191, 14),
woosh.Token(woosh.NAME, 'tarinfo', 2191, 15, 2191, 22),
woosh.Token(woosh.OP, '.', 2191, 22, 2191, 23),
woosh.Token(woosh.NAME, 'sparse', 2191, 23, 2191, 29),
woosh.Token(woosh.NAME, 'is', 2191, 30, 2191, 32),
woosh.Token(woosh.NAME, 'not', 2191, 33, 2191, 36),
woosh.Token(woosh.NAME, 'None', 2191, 37, 2191, 41),
woosh.Token(woosh.OP, ':', 2191, 41, 2191, 42),
woosh.Token(woosh.NEWLINE, '\r\n', 2191, 42, 2192, 0),
woosh.Token(woosh.INDENT, ' ', 2192, 0, 2192, 16),
woosh.Token(woosh.NAME, 'for', 2192, 16, 2192, 19),
woosh.Token(woosh.NAME, 'offset', 2192, 20, 2192, 26),
woosh.Token(woosh.OP, ',', 2192, 26, 2192, 27),
woosh.Token(woosh.NAME, 'size', 2192, 28, 2192, 32),
woosh.Token(woosh.NAME, 'in', 2192, 33, 2192, 35),
woosh.Token(woosh.NAME, 'tarinfo', 2192, 36, 2192, 43),
woosh.Token(woosh.OP, '.', 2192, 43, 2192, 44),
woosh.Token(woosh.NAME, 'sparse', 2192, 44, 2192, 50),
woosh.Token(woosh.OP, ':', 2192, 50, 2192, 51),
woosh.Token(woosh.NEWLINE, '\r\n', 2192, 51, 2193, 0),
woosh.Token(woosh.INDENT, ' ', 2193, 0, 2193, 20),
woosh.Token(woosh.NAME, 'target', 2193, 20, 2193, 26),
woosh.Token(woosh.OP, '.', 2193, 26, 2193, 27),
woosh.Token(woosh.NAME, 'seek', 2193, 27, 2193, 31),
woosh.Token(woosh.OP, '(', 2193, 31, 2193, 32),
woosh.Token(woosh.NAME, 'offset', 2193, 32, 2193, 38),
woosh.Token(woosh.OP, ')', 2193, 38, 2193, 39),
woosh.Token(woosh.NEWLINE, '\r\n', 2193, 39, 2194, 0),
woosh.Token(woosh.NAME, 'copyfileobj', 2194, 20, 2194, 31),
woosh.Token(woosh.OP, '(', 2194, 31, 2194, 32),
woosh.Token(woosh.NAME, 'source', 2194, 32, 2194, 38),
woosh.Token(woosh.OP, ',', 2194, 38, 2194, 39),
woosh.Token(woosh.NAME, 'target', 2194, 40, 2194, 46),
woosh.Token(woosh.OP, ',', 2194, 46, 2194, 47),
woosh.Token(woosh.NAME, 'size', 2194, 48, 2194, 52),
woosh.Token(woosh.OP, ',', 2194, 52, 2194, 53),
woosh.Token(woosh.NAME, 'ReadError', 2194, 54, 2194, 63),
woosh.Token(woosh.OP, ',', 2194, 63, 2194, 64),
woosh.Token(woosh.NAME, 'bufsize', 2194, 65, 2194, 72),
woosh.Token(woosh.OP, ')', 2194, 72, 2194, 73),
woosh.Token(woosh.NEWLINE, '\r\n', 2194, 73, 2195, 0),
woosh.Token(woosh.DEDENT, ' ', 2195, 0, 2195, 16),
woosh.Token(woosh.NAME, 'target', 2195, 16, 2195, 22),
woosh.Token(woosh.OP, '.', 2195, 22, 2195, 23),
woosh.Token(woosh.NAME, 'seek', 2195, 23, 2195, 27),
woosh.Token(woosh.OP, '(', 2195, 27, 2195, 28),
woosh.Token(woosh.NAME, 'tarinfo', 2195, 28, 2195, 35),
woosh.Token(woosh.OP, '.', 2195, 35, 2195, 36),
woosh.Token(woosh.NAME, 'size', 2195, 36, 2195, 40),
woosh.Token(woosh.OP, ')', 2195, 40, 2195, 41),
woosh.Token(woosh.NEWLINE, '\r\n', 2195, 41, 2196, 0),
woosh.Token(woosh.NAME, 'target', 2196, 16, 2196, 22),
woosh.Token(woosh.OP, '.', 2196, 22, 2196, 23),
woosh.Token(woosh.NAME, 'truncate', 2196, 23, 2196, 31),
woosh.Token(woosh.OP, '(', 2196, 31, 2196, 32),
woosh.Token(woosh.OP, ')', 2196, 32, 2196, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 2196, 33, 2197, 0),
woosh.Token(woosh.DEDENT, ' ', 2197, 0, 2197, 12),
woosh.Token(woosh.NAME, 'else', 2197, 12, 2197, 16),
woosh.Token(woosh.OP, ':', 2197, 16, 2197, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 2197, 17, 2198, 0),
woosh.Token(woosh.INDENT, ' ', 2198, 0, 2198, 16),
woosh.Token(woosh.NAME, 'copyfileobj', 2198, 16, 2198, 27),
woosh.Token(woosh.OP, '(', 2198, 27, 2198, 28),
woosh.Token(woosh.NAME, 'source', 2198, 28, 2198, 34),
woosh.Token(woosh.OP, ',', 2198, 34, 2198, 35),
woosh.Token(woosh.NAME, 'target', 2198, 36, 2198, 42),
woosh.Token(woosh.OP, ',', 2198, 42, 2198, 43),
woosh.Token(woosh.NAME, 'tarinfo', 2198, 44, 2198, 51),
woosh.Token(woosh.OP, '.', 2198, 51, 2198, 52),
woosh.Token(woosh.NAME, 'size', 2198, 52, 2198, 56),
woosh.Token(woosh.OP, ',', 2198, 56, 2198, 57),
woosh.Token(woosh.NAME, 'ReadError', 2198, 58, 2198, 67),
woosh.Token(woosh.OP, ',', 2198, 67, 2198, 68),
woosh.Token(woosh.NAME, 'bufsize', 2198, 69, 2198, 76),
woosh.Token(woosh.OP, ')', 2198, 76, 2198, 77),
woosh.Token(woosh.NEWLINE, '\r\n', 2198, 77, 2199, 0),
woosh.Token(woosh.DEDENT, ' ', 2200, 0, 2200, 4),
woosh.Token(woosh.DEDENT, '', 2200, 4, 2200, 4),
woosh.Token(woosh.DEDENT, '', 2200, 4, 2200, 4),
woosh.Token(woosh.NAME, 'def', 2200, 4, 2200, 7),
woosh.Token(woosh.NAME, 'makeunknown', 2200, 8, 2200, 19),
woosh.Token(woosh.OP, '(', 2200, 19, 2200, 20),
woosh.Token(woosh.NAME, 'self', 2200, 20, 2200, 24),
woosh.Token(woosh.OP, ',', 2200, 24, 2200, 25),
woosh.Token(woosh.NAME, 'tarinfo', 2200, 26, 2200, 33),
woosh.Token(woosh.OP, ',', 2200, 33, 2200, 34),
woosh.Token(woosh.NAME, 'targetpath', 2200, 35, 2200, 45),
woosh.Token(woosh.OP, ')', 2200, 45, 2200, 46),
woosh.Token(woosh.OP, ':', 2200, 46, 2200, 47),
woosh.Token(woosh.NEWLINE, '\r\n', 2200, 47, 2201, 0),
woosh.Token(woosh.INDENT, ' ', 2201, 0, 2201, 8),
woosh.Token(woosh.STRING, '"""Make a file from a TarInfo object with an unknown type\r\n at targetpath.\r\n """', 2201, 8, 2203, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 2203, 11, 2204, 0),
woosh.Token(woosh.NAME, 'self', 2204, 8, 2204, 12),
woosh.Token(woosh.OP, '.', 2204, 12, 2204, 13),
woosh.Token(woosh.NAME, 'makefile', 2204, 13, 2204, 21),
woosh.Token(woosh.OP, '(', 2204, 21, 2204, 22),
woosh.Token(woosh.NAME, 'tarinfo', 2204, 22, 2204, 29),
woosh.Token(woosh.OP, ',', 2204, 29, 2204, 30),
woosh.Token(woosh.NAME, 'targetpath', 2204, 31, 2204, 41),
woosh.Token(woosh.OP, ')', 2204, 41, 2204, 42),
woosh.Token(woosh.NEWLINE, '\r\n', 2204, 42, 2205, 0),
woosh.Token(woosh.NAME, 'self', 2205, 8, 2205, 12),
woosh.Token(woosh.OP, '.', 2205, 12, 2205, 13),
woosh.Token(woosh.NAME, '_dbg', 2205, 13, 2205, 17),
woosh.Token(woosh.OP, '(', 2205, 17, 2205, 18),
woosh.Token(woosh.NUMBER, '1', 2205, 18, 2205, 19),
woosh.Token(woosh.OP, ',', 2205, 19, 2205, 20),
woosh.Token(woosh.STRING, '"tarfile: Unknown file type %r, "', 2205, 21, 2205, 54),
woosh.Token(woosh.STRING, '"extracted as regular file."', 2206, 21, 2206, 49),
woosh.Token(woosh.OP, '%', 2206, 50, 2206, 51),
woosh.Token(woosh.NAME, 'tarinfo', 2206, 52, 2206, 59),
woosh.Token(woosh.OP, '.', 2206, 59, 2206, 60),
woosh.Token(woosh.NAME, 'type', 2206, 60, 2206, 64),
woosh.Token(woosh.OP, ')', 2206, 64, 2206, 65),
woosh.Token(woosh.NEWLINE, '\r\n', 2206, 65, 2207, 0),
woosh.Token(woosh.DEDENT, ' ', 2208, 0, 2208, 4),
woosh.Token(woosh.NAME, 'def', 2208, 4, 2208, 7),
woosh.Token(woosh.NAME, 'makefifo', 2208, 8, 2208, 16),
woosh.Token(woosh.OP, '(', 2208, 16, 2208, 17),
woosh.Token(woosh.NAME, 'self', 2208, 17, 2208, 21),
woosh.Token(woosh.OP, ',', 2208, 21, 2208, 22),
woosh.Token(woosh.NAME, 'tarinfo', 2208, 23, 2208, 30),
woosh.Token(woosh.OP, ',', 2208, 30, 2208, 31),
woosh.Token(woosh.NAME, 'targetpath', 2208, 32, 2208, 42),
woosh.Token(woosh.OP, ')', 2208, 42, 2208, 43),
woosh.Token(woosh.OP, ':', 2208, 43, 2208, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 2208, 44, 2209, 0),
woosh.Token(woosh.INDENT, ' ', 2209, 0, 2209, 8),
woosh.Token(woosh.STRING, '"""Make a fifo called targetpath.\r\n """', 2209, 8, 2210, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 2210, 11, 2211, 0),
woosh.Token(woosh.NAME, 'if', 2211, 8, 2211, 10),
woosh.Token(woosh.NAME, 'hasattr', 2211, 11, 2211, 18),
woosh.Token(woosh.OP, '(', 2211, 18, 2211, 19),
woosh.Token(woosh.NAME, 'os', 2211, 19, 2211, 21),
woosh.Token(woosh.OP, ',', 2211, 21, 2211, 22),
woosh.Token(woosh.STRING, '"mkfifo"', 2211, 23, 2211, 31),
woosh.Token(woosh.OP, ')', 2211, 31, 2211, 32),
woosh.Token(woosh.OP, ':', 2211, 32, 2211, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 2211, 33, 2212, 0),
woosh.Token(woosh.INDENT, ' ', 2212, 0, 2212, 12),
woosh.Token(woosh.NAME, 'os', 2212, 12, 2212, 14),
woosh.Token(woosh.OP, '.', 2212, 14, 2212, 15),
woosh.Token(woosh.NAME, 'mkfifo', 2212, 15, 2212, 21),
woosh.Token(woosh.OP, '(', 2212, 21, 2212, 22),
woosh.Token(woosh.NAME, 'targetpath', 2212, 22, 2212, 32),
woosh.Token(woosh.OP, ')', 2212, 32, 2212, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 2212, 33, 2213, 0),
woosh.Token(woosh.DEDENT, ' ', 2213, 0, 2213, 8),
woosh.Token(woosh.NAME, 'else', 2213, 8, 2213, 12),
woosh.Token(woosh.OP, ':', 2213, 12, 2213, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 2213, 13, 2214, 0),
woosh.Token(woosh.INDENT, ' ', 2214, 0, 2214, 12),
woosh.Token(woosh.NAME, 'raise', 2214, 12, 2214, 17),
woosh.Token(woosh.NAME, 'ExtractError', 2214, 18, 2214, 30),
woosh.Token(woosh.OP, '(', 2214, 30, 2214, 31),
woosh.Token(woosh.STRING, '"fifo not supported by system"', 2214, 31, 2214, 61),
woosh.Token(woosh.OP, ')', 2214, 61, 2214, 62),
woosh.Token(woosh.NEWLINE, '\r\n', 2214, 62, 2215, 0),
woosh.Token(woosh.DEDENT, ' ', 2216, 0, 2216, 4),
woosh.Token(woosh.DEDENT, '', 2216, 4, 2216, 4),
woosh.Token(woosh.NAME, 'def', 2216, 4, 2216, 7),
woosh.Token(woosh.NAME, 'makedev', 2216, 8, 2216, 15),
woosh.Token(woosh.OP, '(', 2216, 15, 2216, 16),
woosh.Token(woosh.NAME, 'self', 2216, 16, 2216, 20),
woosh.Token(woosh.OP, ',', 2216, 20, 2216, 21),
woosh.Token(woosh.NAME, 'tarinfo', 2216, 22, 2216, 29),
woosh.Token(woosh.OP, ',', 2216, 29, 2216, 30),
woosh.Token(woosh.NAME, 'targetpath', 2216, 31, 2216, 41),
woosh.Token(woosh.OP, ')', 2216, 41, 2216, 42),
woosh.Token(woosh.OP, ':', 2216, 42, 2216, 43),
woosh.Token(woosh.NEWLINE, '\r\n', 2216, 43, 2217, 0),
woosh.Token(woosh.INDENT, ' ', 2217, 0, 2217, 8),
woosh.Token(woosh.STRING, '"""Make a character or block device called targetpath.\r\n """', 2217, 8, 2218, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 2218, 11, 2219, 0),
woosh.Token(woosh.NAME, 'if', 2219, 8, 2219, 10),
woosh.Token(woosh.NAME, 'not', 2219, 11, 2219, 14),
woosh.Token(woosh.NAME, 'hasattr', 2219, 15, 2219, 22),
woosh.Token(woosh.OP, '(', 2219, 22, 2219, 23),
woosh.Token(woosh.NAME, 'os', 2219, 23, 2219, 25),
woosh.Token(woosh.OP, ',', 2219, 25, 2219, 26),
woosh.Token(woosh.STRING, '"mknod"', 2219, 27, 2219, 34),
woosh.Token(woosh.OP, ')', 2219, 34, 2219, 35),
woosh.Token(woosh.NAME, 'or', 2219, 36, 2219, 38),
woosh.Token(woosh.NAME, 'not', 2219, 39, 2219, 42),
woosh.Token(woosh.NAME, 'hasattr', 2219, 43, 2219, 50),
woosh.Token(woosh.OP, '(', 2219, 50, 2219, 51),
woosh.Token(woosh.NAME, 'os', 2219, 51, 2219, 53),
woosh.Token(woosh.OP, ',', 2219, 53, 2219, 54),
woosh.Token(woosh.STRING, '"makedev"', 2219, 55, 2219, 64),
woosh.Token(woosh.OP, ')', 2219, 64, 2219, 65),
woosh.Token(woosh.OP, ':', 2219, 65, 2219, 66),
woosh.Token(woosh.NEWLINE, '\r\n', 2219, 66, 2220, 0),
woosh.Token(woosh.INDENT, ' ', 2220, 0, 2220, 12),
woosh.Token(woosh.NAME, 'raise', 2220, 12, 2220, 17),
woosh.Token(woosh.NAME, 'ExtractError', 2220, 18, 2220, 30),
woosh.Token(woosh.OP, '(', 2220, 30, 2220, 31),
woosh.Token(woosh.STRING, '"special devices not supported by system"', 2220, 31, 2220, 72),
woosh.Token(woosh.OP, ')', 2220, 72, 2220, 73),
woosh.Token(woosh.NEWLINE, '\r\n', 2220, 73, 2221, 0),
woosh.Token(woosh.DEDENT, ' ', 2222, 0, 2222, 8),
woosh.Token(woosh.NAME, 'mode', 2222, 8, 2222, 12),
woosh.Token(woosh.OP, '=', 2222, 13, 2222, 14),
woosh.Token(woosh.NAME, 'tarinfo', 2222, 15, 2222, 22),
woosh.Token(woosh.OP, '.', 2222, 22, 2222, 23),
woosh.Token(woosh.NAME, 'mode', 2222, 23, 2222, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 2222, 27, 2223, 0),
woosh.Token(woosh.NAME, 'if', 2223, 8, 2223, 10),
woosh.Token(woosh.NAME, 'tarinfo', 2223, 11, 2223, 18),
woosh.Token(woosh.OP, '.', 2223, 18, 2223, 19),
woosh.Token(woosh.NAME, 'isblk', 2223, 19, 2223, 24),
woosh.Token(woosh.OP, '(', 2223, 24, 2223, 25),
woosh.Token(woosh.OP, ')', 2223, 25, 2223, 26),
woosh.Token(woosh.OP, ':', 2223, 26, 2223, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 2223, 27, 2224, 0),
woosh.Token(woosh.INDENT, ' ', 2224, 0, 2224, 12),
woosh.Token(woosh.NAME, 'mode', 2224, 12, 2224, 16),
woosh.Token(woosh.OP, '|=', 2224, 17, 2224, 19),
woosh.Token(woosh.NAME, 'stat', 2224, 20, 2224, 24),
woosh.Token(woosh.OP, '.', 2224, 24, 2224, 25),
woosh.Token(woosh.NAME, 'S_IFBLK', 2224, 25, 2224, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 2224, 32, 2225, 0),
woosh.Token(woosh.DEDENT, ' ', 2225, 0, 2225, 8),
woosh.Token(woosh.NAME, 'else', 2225, 8, 2225, 12),
woosh.Token(woosh.OP, ':', 2225, 12, 2225, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 2225, 13, 2226, 0),
woosh.Token(woosh.INDENT, ' ', 2226, 0, 2226, 12),
woosh.Token(woosh.NAME, 'mode', 2226, 12, 2226, 16),
woosh.Token(woosh.OP, '|=', 2226, 17, 2226, 19),
woosh.Token(woosh.NAME, 'stat', 2226, 20, 2226, 24),
woosh.Token(woosh.OP, '.', 2226, 24, 2226, 25),
woosh.Token(woosh.NAME, 'S_IFCHR', 2226, 25, 2226, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 2226, 32, 2227, 0),
woosh.Token(woosh.DEDENT, ' ', 2228, 0, 2228, 8),
woosh.Token(woosh.NAME, 'os', 2228, 8, 2228, 10),
woosh.Token(woosh.OP, '.', 2228, 10, 2228, 11),
woosh.Token(woosh.NAME, 'mknod', 2228, 11, 2228, 16),
woosh.Token(woosh.OP, '(', 2228, 16, 2228, 17),
woosh.Token(woosh.NAME, 'targetpath', 2228, 17, 2228, 27),
woosh.Token(woosh.OP, ',', 2228, 27, 2228, 28),
woosh.Token(woosh.NAME, 'mode', 2228, 29, 2228, 33),
woosh.Token(woosh.OP, ',', 2228, 33, 2228, 34),
woosh.Token(woosh.NAME, 'os', 2229, 17, 2229, 19),
woosh.Token(woosh.OP, '.', 2229, 19, 2229, 20),
woosh.Token(woosh.NAME, 'makedev', 2229, 20, 2229, 27),
woosh.Token(woosh.OP, '(', 2229, 27, 2229, 28),
woosh.Token(woosh.NAME, 'tarinfo', 2229, 28, 2229, 35),
woosh.Token(woosh.OP, '.', 2229, 35, 2229, 36),
woosh.Token(woosh.NAME, 'devmajor', 2229, 36, 2229, 44),
woosh.Token(woosh.OP, ',', 2229, 44, 2229, 45),
woosh.Token(woosh.NAME, 'tarinfo', 2229, 46, 2229, 53),
woosh.Token(woosh.OP, '.', 2229, 53, 2229, 54),
woosh.Token(woosh.NAME, 'devminor', 2229, 54, 2229, 62),
woosh.Token(woosh.OP, ')', 2229, 62, 2229, 63),
woosh.Token(woosh.OP, ')', 2229, 63, 2229, 64),
woosh.Token(woosh.NEWLINE, '\r\n', 2229, 64, 2230, 0),
woosh.Token(woosh.DEDENT, ' ', 2231, 0, 2231, 4),
woosh.Token(woosh.NAME, 'def', 2231, 4, 2231, 7),
woosh.Token(woosh.NAME, 'makelink', 2231, 8, 2231, 16),
woosh.Token(woosh.OP, '(', 2231, 16, 2231, 17),
woosh.Token(woosh.NAME, 'self', 2231, 17, 2231, 21),
woosh.Token(woosh.OP, ',', 2231, 21, 2231, 22),
woosh.Token(woosh.NAME, 'tarinfo', 2231, 23, 2231, 30),
woosh.Token(woosh.OP, ',', 2231, 30, 2231, 31),
woosh.Token(woosh.NAME, 'targetpath', 2231, 32, 2231, 42),
woosh.Token(woosh.OP, ')', 2231, 42, 2231, 43),
woosh.Token(woosh.OP, ':', 2231, 43, 2231, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 2231, 44, 2232, 0),
woosh.Token(woosh.INDENT, ' ', 2232, 0, 2232, 8),
woosh.Token(woosh.STRING, '"""Make a (symbolic) link called targetpath. If it cannot be created\r\n (platform limitation), we try to make a copy of the referenced file\r\n instead of a link.\r\n """', 2232, 8, 2235, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 2235, 11, 2236, 0),
woosh.Token(woosh.NAME, 'try', 2236, 8, 2236, 11),
woosh.Token(woosh.OP, ':', 2236, 11, 2236, 12),
woosh.Token(woosh.NEWLINE, '\r\n', 2236, 12, 2237, 0),
woosh.Token(woosh.COMMENT, '# For systems that support symbolic and hard links.', 2237, 12, 2237, 63),
woosh.Token(woosh.INDENT, ' ', 2238, 0, 2238, 12),
woosh.Token(woosh.NAME, 'if', 2238, 12, 2238, 14),
woosh.Token(woosh.NAME, 'tarinfo', 2238, 15, 2238, 22),
woosh.Token(woosh.OP, '.', 2238, 22, 2238, 23),
woosh.Token(woosh.NAME, 'issym', 2238, 23, 2238, 28),
woosh.Token(woosh.OP, '(', 2238, 28, 2238, 29),
woosh.Token(woosh.OP, ')', 2238, 29, 2238, 30),
woosh.Token(woosh.OP, ':', 2238, 30, 2238, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 2238, 31, 2239, 0),
woosh.Token(woosh.INDENT, ' ', 2239, 0, 2239, 16),
woosh.Token(woosh.NAME, 'os', 2239, 16, 2239, 18),
woosh.Token(woosh.OP, '.', 2239, 18, 2239, 19),
woosh.Token(woosh.NAME, 'symlink', 2239, 19, 2239, 26),
woosh.Token(woosh.OP, '(', 2239, 26, 2239, 27),
woosh.Token(woosh.NAME, 'tarinfo', 2239, 27, 2239, 34),
woosh.Token(woosh.OP, '.', 2239, 34, 2239, 35),
woosh.Token(woosh.NAME, 'linkname', 2239, 35, 2239, 43),
woosh.Token(woosh.OP, ',', 2239, 43, 2239, 44),
woosh.Token(woosh.NAME, 'targetpath', 2239, 45, 2239, 55),
woosh.Token(woosh.OP, ')', 2239, 55, 2239, 56),
woosh.Token(woosh.NEWLINE, '\r\n', 2239, 56, 2240, 0),
woosh.Token(woosh.DEDENT, ' ', 2240, 0, 2240, 12),
woosh.Token(woosh.NAME, 'else', 2240, 12, 2240, 16),
woosh.Token(woosh.OP, ':', 2240, 16, 2240, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 2240, 17, 2241, 0),
woosh.Token(woosh.COMMENT, '# See extract().', 2241, 16, 2241, 32),
woosh.Token(woosh.INDENT, ' ', 2242, 0, 2242, 16),
woosh.Token(woosh.NAME, 'if', 2242, 16, 2242, 18),
woosh.Token(woosh.NAME, 'os', 2242, 19, 2242, 21),
woosh.Token(woosh.OP, '.', 2242, 21, 2242, 22),
woosh.Token(woosh.NAME, 'path', 2242, 22, 2242, 26),
woosh.Token(woosh.OP, '.', 2242, 26, 2242, 27),
woosh.Token(woosh.NAME, 'exists', 2242, 27, 2242, 33),
woosh.Token(woosh.OP, '(', 2242, 33, 2242, 34),
woosh.Token(woosh.NAME, 'tarinfo', 2242, 34, 2242, 41),
woosh.Token(woosh.OP, '.', 2242, 41, 2242, 42),
woosh.Token(woosh.NAME, '_link_target', 2242, 42, 2242, 54),
woosh.Token(woosh.OP, ')', 2242, 54, 2242, 55),
woosh.Token(woosh.OP, ':', 2242, 55, 2242, 56),
woosh.Token(woosh.NEWLINE, '\r\n', 2242, 56, 2243, 0),
woosh.Token(woosh.INDENT, ' ', 2243, 0, 2243, 20),
woosh.Token(woosh.NAME, 'os', 2243, 20, 2243, 22),
woosh.Token(woosh.OP, '.', 2243, 22, 2243, 23),
woosh.Token(woosh.NAME, 'link', 2243, 23, 2243, 27),
woosh.Token(woosh.OP, '(', 2243, 27, 2243, 28),
woosh.Token(woosh.NAME, 'tarinfo', 2243, 28, 2243, 35),
woosh.Token(woosh.OP, '.', 2243, 35, 2243, 36),
woosh.Token(woosh.NAME, '_link_target', 2243, 36, 2243, 48),
woosh.Token(woosh.OP, ',', 2243, 48, 2243, 49),
woosh.Token(woosh.NAME, 'targetpath', 2243, 50, 2243, 60),
woosh.Token(woosh.OP, ')', 2243, 60, 2243, 61),
woosh.Token(woosh.NEWLINE, '\r\n', 2243, 61, 2244, 0),
woosh.Token(woosh.DEDENT, ' ', 2244, 0, 2244, 16),
woosh.Token(woosh.NAME, 'else', 2244, 16, 2244, 20),
woosh.Token(woosh.OP, ':', 2244, 20, 2244, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 2244, 21, 2245, 0),
woosh.Token(woosh.INDENT, ' ', 2245, 0, 2245, 20),
woosh.Token(woosh.NAME, 'self', 2245, 20, 2245, 24),
woosh.Token(woosh.OP, '.', 2245, 24, 2245, 25),
woosh.Token(woosh.NAME, '_extract_member', 2245, 25, 2245, 40),
woosh.Token(woosh.OP, '(', 2245, 40, 2245, 41),
woosh.Token(woosh.NAME, 'self', 2245, 41, 2245, 45),
woosh.Token(woosh.OP, '.', 2245, 45, 2245, 46),
woosh.Token(woosh.NAME, '_find_link_target', 2245, 46, 2245, 63),
woosh.Token(woosh.OP, '(', 2245, 63, 2245, 64),
woosh.Token(woosh.NAME, 'tarinfo', 2245, 64, 2245, 71),
woosh.Token(woosh.OP, ')', 2245, 71, 2245, 72),
woosh.Token(woosh.OP, ',', 2245, 72, 2245, 73),
woosh.Token(woosh.NAME, 'targetpath', 2246, 41, 2246, 51),
woosh.Token(woosh.OP, ')', 2246, 51, 2246, 52),
woosh.Token(woosh.NEWLINE, '\r\n', 2246, 52, 2247, 0),
woosh.Token(woosh.DEDENT, ' ', 2247, 0, 2247, 8),
woosh.Token(woosh.DEDENT, '', 2247, 8, 2247, 8),
woosh.Token(woosh.DEDENT, '', 2247, 8, 2247, 8),
woosh.Token(woosh.NAME, 'except', 2247, 8, 2247, 14),
woosh.Token(woosh.NAME, 'symlink_exception', 2247, 15, 2247, 32),
woosh.Token(woosh.OP, ':', 2247, 32, 2247, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 2247, 33, 2248, 0),
woosh.Token(woosh.INDENT, ' ', 2248, 0, 2248, 12),
woosh.Token(woosh.NAME, 'try', 2248, 12, 2248, 15),
woosh.Token(woosh.OP, ':', 2248, 15, 2248, 16),
woosh.Token(woosh.NEWLINE, '\r\n', 2248, 16, 2249, 0),
woosh.Token(woosh.INDENT, ' ', 2249, 0, 2249, 16),
woosh.Token(woosh.NAME, 'self', 2249, 16, 2249, 20),
woosh.Token(woosh.OP, '.', 2249, 20, 2249, 21),
woosh.Token(woosh.NAME, '_extract_member', 2249, 21, 2249, 36),
woosh.Token(woosh.OP, '(', 2249, 36, 2249, 37),
woosh.Token(woosh.NAME, 'self', 2249, 37, 2249, 41),
woosh.Token(woosh.OP, '.', 2249, 41, 2249, 42),
woosh.Token(woosh.NAME, '_find_link_target', 2249, 42, 2249, 59),
woosh.Token(woosh.OP, '(', 2249, 59, 2249, 60),
woosh.Token(woosh.NAME, 'tarinfo', 2249, 60, 2249, 67),
woosh.Token(woosh.OP, ')', 2249, 67, 2249, 68),
woosh.Token(woosh.OP, ',', 2249, 68, 2249, 69),
woosh.Token(woosh.NAME, 'targetpath', 2250, 37, 2250, 47),
woosh.Token(woosh.OP, ')', 2250, 47, 2250, 48),
woosh.Token(woosh.NEWLINE, '\r\n', 2250, 48, 2251, 0),
woosh.Token(woosh.DEDENT, ' ', 2251, 0, 2251, 12),
woosh.Token(woosh.NAME, 'except', 2251, 12, 2251, 18),
woosh.Token(woosh.NAME, 'KeyError', 2251, 19, 2251, 27),
woosh.Token(woosh.OP, ':', 2251, 27, 2251, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 2251, 28, 2252, 0),
woosh.Token(woosh.INDENT, ' ', 2252, 0, 2252, 16),
woosh.Token(woosh.NAME, 'raise', 2252, 16, 2252, 21),
woosh.Token(woosh.NAME, 'ExtractError', 2252, 22, 2252, 34),
woosh.Token(woosh.OP, '(', 2252, 34, 2252, 35),
woosh.Token(woosh.STRING, '"unable to resolve link inside archive"', 2252, 35, 2252, 74),
woosh.Token(woosh.OP, ')', 2252, 74, 2252, 75),
woosh.Token(woosh.NEWLINE, '\r\n', 2252, 75, 2253, 0),
woosh.Token(woosh.DEDENT, ' ', 2254, 0, 2254, 4),
woosh.Token(woosh.DEDENT, '', 2254, 4, 2254, 4),
woosh.Token(woosh.DEDENT, '', 2254, 4, 2254, 4),
woosh.Token(woosh.NAME, 'def', 2254, 4, 2254, 7),
woosh.Token(woosh.NAME, 'chown', 2254, 8, 2254, 13),
woosh.Token(woosh.OP, '(', 2254, 13, 2254, 14),
woosh.Token(woosh.NAME, 'self', 2254, 14, 2254, 18),
woosh.Token(woosh.OP, ',', 2254, 18, 2254, 19),
woosh.Token(woosh.NAME, 'tarinfo', 2254, 20, 2254, 27),
woosh.Token(woosh.OP, ',', 2254, 27, 2254, 28),
woosh.Token(woosh.NAME, 'targetpath', 2254, 29, 2254, 39),
woosh.Token(woosh.OP, ',', 2254, 39, 2254, 40),
woosh.Token(woosh.NAME, 'numeric_owner', 2254, 41, 2254, 54),
woosh.Token(woosh.OP, ')', 2254, 54, 2254, 55),
woosh.Token(woosh.OP, ':', 2254, 55, 2254, 56),
woosh.Token(woosh.NEWLINE, '\r\n', 2254, 56, 2255, 0),
woosh.Token(woosh.INDENT, ' ', 2255, 0, 2255, 8),
woosh.Token(woosh.STRING, '"""Set owner of targetpath according to tarinfo. If numeric_owner\r\n is True, use .gid/.uid instead of .gname/.uname. If numeric_owner\r\n is False, fall back to .gid/.uid when the search based on name\r\n fails.\r\n """', 2255, 8, 2259, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 2259, 11, 2260, 0),
woosh.Token(woosh.NAME, 'if', 2260, 8, 2260, 10),
woosh.Token(woosh.NAME, 'hasattr', 2260, 11, 2260, 18),
woosh.Token(woosh.OP, '(', 2260, 18, 2260, 19),
woosh.Token(woosh.NAME, 'os', 2260, 19, 2260, 21),
woosh.Token(woosh.OP, ',', 2260, 21, 2260, 22),
woosh.Token(woosh.STRING, '"geteuid"', 2260, 23, 2260, 32),
woosh.Token(woosh.OP, ')', 2260, 32, 2260, 33),
woosh.Token(woosh.NAME, 'and', 2260, 34, 2260, 37),
woosh.Token(woosh.NAME, 'os', 2260, 38, 2260, 40),
woosh.Token(woosh.OP, '.', 2260, 40, 2260, 41),
woosh.Token(woosh.NAME, 'geteuid', 2260, 41, 2260, 48),
woosh.Token(woosh.OP, '(', 2260, 48, 2260, 49),
woosh.Token(woosh.OP, ')', 2260, 49, 2260, 50),
woosh.Token(woosh.OP, '==', 2260, 51, 2260, 53),
woosh.Token(woosh.NUMBER, '0', 2260, 54, 2260, 55),
woosh.Token(woosh.OP, ':', 2260, 55, 2260, 56),
woosh.Token(woosh.NEWLINE, '\r\n', 2260, 56, 2261, 0),
woosh.Token(woosh.COMMENT, '# We have to be root to do so.', 2261, 12, 2261, 42),
woosh.Token(woosh.INDENT, ' ', 2262, 0, 2262, 12),
woosh.Token(woosh.NAME, 'g', 2262, 12, 2262, 13),
woosh.Token(woosh.OP, '=', 2262, 14, 2262, 15),
woosh.Token(woosh.NAME, 'tarinfo', 2262, 16, 2262, 23),
woosh.Token(woosh.OP, '.', 2262, 23, 2262, 24),
woosh.Token(woosh.NAME, 'gid', 2262, 24, 2262, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 2262, 27, 2263, 0),
woosh.Token(woosh.NAME, 'u', 2263, 12, 2263, 13),
woosh.Token(woosh.OP, '=', 2263, 14, 2263, 15),
woosh.Token(woosh.NAME, 'tarinfo', 2263, 16, 2263, 23),
woosh.Token(woosh.OP, '.', 2263, 23, 2263, 24),
woosh.Token(woosh.NAME, 'uid', 2263, 24, 2263, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 2263, 27, 2264, 0),
woosh.Token(woosh.NAME, 'if', 2264, 12, 2264, 14),
woosh.Token(woosh.NAME, 'not', 2264, 15, 2264, 18),
woosh.Token(woosh.NAME, 'numeric_owner', 2264, 19, 2264, 32),
woosh.Token(woosh.OP, ':', 2264, 32, 2264, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 2264, 33, 2265, 0),
woosh.Token(woosh.INDENT, ' ', 2265, 0, 2265, 16),
woosh.Token(woosh.NAME, 'try', 2265, 16, 2265, 19),
woosh.Token(woosh.OP, ':', 2265, 19, 2265, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 2265, 20, 2266, 0),
woosh.Token(woosh.INDENT, ' ', 2266, 0, 2266, 20),
woosh.Token(woosh.NAME, 'if', 2266, 20, 2266, 22),
woosh.Token(woosh.NAME, 'grp', 2266, 23, 2266, 26),
woosh.Token(woosh.OP, ':', 2266, 26, 2266, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 2266, 27, 2267, 0),
woosh.Token(woosh.INDENT, ' ', 2267, 0, 2267, 24),
woosh.Token(woosh.NAME, 'g', 2267, 24, 2267, 25),
woosh.Token(woosh.OP, '=', 2267, 26, 2267, 27),
woosh.Token(woosh.NAME, 'grp', 2267, 28, 2267, 31),
woosh.Token(woosh.OP, '.', 2267, 31, 2267, 32),
woosh.Token(woosh.NAME, 'getgrnam', 2267, 32, 2267, 40),
woosh.Token(woosh.OP, '(', 2267, 40, 2267, 41),
woosh.Token(woosh.NAME, 'tarinfo', 2267, 41, 2267, 48),
woosh.Token(woosh.OP, '.', 2267, 48, 2267, 49),
woosh.Token(woosh.NAME, 'gname', 2267, 49, 2267, 54),
woosh.Token(woosh.OP, ')', 2267, 54, 2267, 55),
woosh.Token(woosh.OP, '[', 2267, 55, 2267, 56),
woosh.Token(woosh.NUMBER, '2', 2267, 56, 2267, 57),
woosh.Token(woosh.OP, ']', 2267, 57, 2267, 58),
woosh.Token(woosh.NEWLINE, '\r\n', 2267, 58, 2268, 0),
woosh.Token(woosh.DEDENT, ' ', 2268, 0, 2268, 16),
woosh.Token(woosh.DEDENT, '', 2268, 16, 2268, 16),
woosh.Token(woosh.NAME, 'except', 2268, 16, 2268, 22),
woosh.Token(woosh.NAME, 'KeyError', 2268, 23, 2268, 31),
woosh.Token(woosh.OP, ':', 2268, 31, 2268, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 2268, 32, 2269, 0),
woosh.Token(woosh.INDENT, ' ', 2269, 0, 2269, 20),
woosh.Token(woosh.NAME, 'pass', 2269, 20, 2269, 24),
woosh.Token(woosh.NEWLINE, '\r\n', 2269, 24, 2270, 0),
woosh.Token(woosh.DEDENT, ' ', 2270, 0, 2270, 16),
woosh.Token(woosh.NAME, 'try', 2270, 16, 2270, 19),
woosh.Token(woosh.OP, ':', 2270, 19, 2270, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 2270, 20, 2271, 0),
woosh.Token(woosh.INDENT, ' ', 2271, 0, 2271, 20),
woosh.Token(woosh.NAME, 'if', 2271, 20, 2271, 22),
woosh.Token(woosh.NAME, 'pwd', 2271, 23, 2271, 26),
woosh.Token(woosh.OP, ':', 2271, 26, 2271, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 2271, 27, 2272, 0),
woosh.Token(woosh.INDENT, ' ', 2272, 0, 2272, 24),
woosh.Token(woosh.NAME, 'u', 2272, 24, 2272, 25),
woosh.Token(woosh.OP, '=', 2272, 26, 2272, 27),
woosh.Token(woosh.NAME, 'pwd', 2272, 28, 2272, 31),
woosh.Token(woosh.OP, '.', 2272, 31, 2272, 32),
woosh.Token(woosh.NAME, 'getpwnam', 2272, 32, 2272, 40),
woosh.Token(woosh.OP, '(', 2272, 40, 2272, 41),
woosh.Token(woosh.NAME, 'tarinfo', 2272, 41, 2272, 48),
woosh.Token(woosh.OP, '.', 2272, 48, 2272, 49),
woosh.Token(woosh.NAME, 'uname', 2272, 49, 2272, 54),
woosh.Token(woosh.OP, ')', 2272, 54, 2272, 55),
woosh.Token(woosh.OP, '[', 2272, 55, 2272, 56),
woosh.Token(woosh.NUMBER, '2', 2272, 56, 2272, 57),
woosh.Token(woosh.OP, ']', 2272, 57, 2272, 58),
woosh.Token(woosh.NEWLINE, '\r\n', 2272, 58, 2273, 0),
woosh.Token(woosh.DEDENT, ' ', 2273, 0, 2273, 16),
woosh.Token(woosh.DEDENT, '', 2273, 16, 2273, 16),
woosh.Token(woosh.NAME, 'except', 2273, 16, 2273, 22),
woosh.Token(woosh.NAME, 'KeyError', 2273, 23, 2273, 31),
woosh.Token(woosh.OP, ':', 2273, 31, 2273, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 2273, 32, 2274, 0),
woosh.Token(woosh.INDENT, ' ', 2274, 0, 2274, 20),
woosh.Token(woosh.NAME, 'pass', 2274, 20, 2274, 24),
woosh.Token(woosh.NEWLINE, '\r\n', 2274, 24, 2275, 0),
woosh.Token(woosh.DEDENT, ' ', 2275, 0, 2275, 12),
woosh.Token(woosh.DEDENT, '', 2275, 12, 2275, 12),
woosh.Token(woosh.NAME, 'try', 2275, 12, 2275, 15),
woosh.Token(woosh.OP, ':', 2275, 15, 2275, 16),
woosh.Token(woosh.NEWLINE, '\r\n', 2275, 16, 2276, 0),
woosh.Token(woosh.INDENT, ' ', 2276, 0, 2276, 16),
woosh.Token(woosh.NAME, 'if', 2276, 16, 2276, 18),
woosh.Token(woosh.NAME, 'tarinfo', 2276, 19, 2276, 26),
woosh.Token(woosh.OP, '.', 2276, 26, 2276, 27),
woosh.Token(woosh.NAME, 'issym', 2276, 27, 2276, 32),
woosh.Token(woosh.OP, '(', 2276, 32, 2276, 33),
woosh.Token(woosh.OP, ')', 2276, 33, 2276, 34),
woosh.Token(woosh.NAME, 'and', 2276, 35, 2276, 38),
woosh.Token(woosh.NAME, 'hasattr', 2276, 39, 2276, 46),
woosh.Token(woosh.OP, '(', 2276, 46, 2276, 47),
woosh.Token(woosh.NAME, 'os', 2276, 47, 2276, 49),
woosh.Token(woosh.OP, ',', 2276, 49, 2276, 50),
woosh.Token(woosh.STRING, '"lchown"', 2276, 51, 2276, 59),
woosh.Token(woosh.OP, ')', 2276, 59, 2276, 60),
woosh.Token(woosh.OP, ':', 2276, 60, 2276, 61),
woosh.Token(woosh.NEWLINE, '\r\n', 2276, 61, 2277, 0),
woosh.Token(woosh.INDENT, ' ', 2277, 0, 2277, 20),
woosh.Token(woosh.NAME, 'os', 2277, 20, 2277, 22),
woosh.Token(woosh.OP, '.', 2277, 22, 2277, 23),
woosh.Token(woosh.NAME, 'lchown', 2277, 23, 2277, 29),
woosh.Token(woosh.OP, '(', 2277, 29, 2277, 30),
woosh.Token(woosh.NAME, 'targetpath', 2277, 30, 2277, 40),
woosh.Token(woosh.OP, ',', 2277, 40, 2277, 41),
woosh.Token(woosh.NAME, 'u', 2277, 42, 2277, 43),
woosh.Token(woosh.OP, ',', 2277, 43, 2277, 44),
woosh.Token(woosh.NAME, 'g', 2277, 45, 2277, 46),
woosh.Token(woosh.OP, ')', 2277, 46, 2277, 47),
woosh.Token(woosh.NEWLINE, '\r\n', 2277, 47, 2278, 0),
woosh.Token(woosh.DEDENT, ' ', 2278, 0, 2278, 16),
woosh.Token(woosh.NAME, 'else', 2278, 16, 2278, 20),
woosh.Token(woosh.OP, ':', 2278, 20, 2278, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 2278, 21, 2279, 0),
woosh.Token(woosh.INDENT, ' ', 2279, 0, 2279, 20),
woosh.Token(woosh.NAME, 'os', 2279, 20, 2279, 22),
woosh.Token(woosh.OP, '.', 2279, 22, 2279, 23),
woosh.Token(woosh.NAME, 'chown', 2279, 23, 2279, 28),
woosh.Token(woosh.OP, '(', 2279, 28, 2279, 29),
woosh.Token(woosh.NAME, 'targetpath', 2279, 29, 2279, 39),
woosh.Token(woosh.OP, ',', 2279, 39, 2279, 40),
woosh.Token(woosh.NAME, 'u', 2279, 41, 2279, 42),
woosh.Token(woosh.OP, ',', 2279, 42, 2279, 43),
woosh.Token(woosh.NAME, 'g', 2279, 44, 2279, 45),
woosh.Token(woosh.OP, ')', 2279, 45, 2279, 46),
woosh.Token(woosh.NEWLINE, '\r\n', 2279, 46, 2280, 0),
woosh.Token(woosh.DEDENT, ' ', 2280, 0, 2280, 12),
woosh.Token(woosh.DEDENT, '', 2280, 12, 2280, 12),
woosh.Token(woosh.NAME, 'except', 2280, 12, 2280, 18),
woosh.Token(woosh.NAME, 'OSError', 2280, 19, 2280, 26),
woosh.Token(woosh.OP, ':', 2280, 26, 2280, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 2280, 27, 2281, 0),
woosh.Token(woosh.INDENT, ' ', 2281, 0, 2281, 16),
woosh.Token(woosh.NAME, 'raise', 2281, 16, 2281, 21),
woosh.Token(woosh.NAME, 'ExtractError', 2281, 22, 2281, 34),
woosh.Token(woosh.OP, '(', 2281, 34, 2281, 35),
woosh.Token(woosh.STRING, '"could not change owner"', 2281, 35, 2281, 59),
woosh.Token(woosh.OP, ')', 2281, 59, 2281, 60),
woosh.Token(woosh.NEWLINE, '\r\n', 2281, 60, 2282, 0),
woosh.Token(woosh.DEDENT, ' ', 2283, 0, 2283, 4),
woosh.Token(woosh.DEDENT, '', 2283, 4, 2283, 4),
woosh.Token(woosh.DEDENT, '', 2283, 4, 2283, 4),
woosh.Token(woosh.NAME, 'def', 2283, 4, 2283, 7),
woosh.Token(woosh.NAME, 'chmod', 2283, 8, 2283, 13),
woosh.Token(woosh.OP, '(', 2283, 13, 2283, 14),
woosh.Token(woosh.NAME, 'self', 2283, 14, 2283, 18),
woosh.Token(woosh.OP, ',', 2283, 18, 2283, 19),
woosh.Token(woosh.NAME, 'tarinfo', 2283, 20, 2283, 27),
woosh.Token(woosh.OP, ',', 2283, 27, 2283, 28),
woosh.Token(woosh.NAME, 'targetpath', 2283, 29, 2283, 39),
woosh.Token(woosh.OP, ')', 2283, 39, 2283, 40),
woosh.Token(woosh.OP, ':', 2283, 40, 2283, 41),
woosh.Token(woosh.NEWLINE, '\r\n', 2283, 41, 2284, 0),
woosh.Token(woosh.INDENT, ' ', 2284, 0, 2284, 8),
woosh.Token(woosh.STRING, '"""Set file permissions of targetpath according to tarinfo.\r\n """', 2284, 8, 2285, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 2285, 11, 2286, 0),
woosh.Token(woosh.NAME, 'try', 2286, 8, 2286, 11),
woosh.Token(woosh.OP, ':', 2286, 11, 2286, 12),
woosh.Token(woosh.NEWLINE, '\r\n', 2286, 12, 2287, 0),
woosh.Token(woosh.INDENT, ' ', 2287, 0, 2287, 12),
woosh.Token(woosh.NAME, 'os', 2287, 12, 2287, 14),
woosh.Token(woosh.OP, '.', 2287, 14, 2287, 15),
woosh.Token(woosh.NAME, 'chmod', 2287, 15, 2287, 20),
woosh.Token(woosh.OP, '(', 2287, 20, 2287, 21),
woosh.Token(woosh.NAME, 'targetpath', 2287, 21, 2287, 31),
woosh.Token(woosh.OP, ',', 2287, 31, 2287, 32),
woosh.Token(woosh.NAME, 'tarinfo', 2287, 33, 2287, 40),
woosh.Token(woosh.OP, '.', 2287, 40, 2287, 41),
woosh.Token(woosh.NAME, 'mode', 2287, 41, 2287, 45),
woosh.Token(woosh.OP, ')', 2287, 45, 2287, 46),
woosh.Token(woosh.NEWLINE, '\r\n', 2287, 46, 2288, 0),
woosh.Token(woosh.DEDENT, ' ', 2288, 0, 2288, 8),
woosh.Token(woosh.NAME, 'except', 2288, 8, 2288, 14),
woosh.Token(woosh.NAME, 'OSError', 2288, 15, 2288, 22),
woosh.Token(woosh.OP, ':', 2288, 22, 2288, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 2288, 23, 2289, 0),
woosh.Token(woosh.INDENT, ' ', 2289, 0, 2289, 12),
woosh.Token(woosh.NAME, 'raise', 2289, 12, 2289, 17),
woosh.Token(woosh.NAME, 'ExtractError', 2289, 18, 2289, 30),
woosh.Token(woosh.OP, '(', 2289, 30, 2289, 31),
woosh.Token(woosh.STRING, '"could not change mode"', 2289, 31, 2289, 54),
woosh.Token(woosh.OP, ')', 2289, 54, 2289, 55),
woosh.Token(woosh.NEWLINE, '\r\n', 2289, 55, 2290, 0),
woosh.Token(woosh.DEDENT, ' ', 2291, 0, 2291, 4),
woosh.Token(woosh.DEDENT, '', 2291, 4, 2291, 4),
woosh.Token(woosh.NAME, 'def', 2291, 4, 2291, 7),
woosh.Token(woosh.NAME, 'utime', 2291, 8, 2291, 13),
woosh.Token(woosh.OP, '(', 2291, 13, 2291, 14),
woosh.Token(woosh.NAME, 'self', 2291, 14, 2291, 18),
woosh.Token(woosh.OP, ',', 2291, 18, 2291, 19),
woosh.Token(woosh.NAME, 'tarinfo', 2291, 20, 2291, 27),
woosh.Token(woosh.OP, ',', 2291, 27, 2291, 28),
woosh.Token(woosh.NAME, 'targetpath', 2291, 29, 2291, 39),
woosh.Token(woosh.OP, ')', 2291, 39, 2291, 40),
woosh.Token(woosh.OP, ':', 2291, 40, 2291, 41),
woosh.Token(woosh.NEWLINE, '\r\n', 2291, 41, 2292, 0),
woosh.Token(woosh.INDENT, ' ', 2292, 0, 2292, 8),
woosh.Token(woosh.STRING, '"""Set modification time of targetpath according to tarinfo.\r\n """', 2292, 8, 2293, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 2293, 11, 2294, 0),
woosh.Token(woosh.NAME, 'if', 2294, 8, 2294, 10),
woosh.Token(woosh.NAME, 'not', 2294, 11, 2294, 14),
woosh.Token(woosh.NAME, 'hasattr', 2294, 15, 2294, 22),
woosh.Token(woosh.OP, '(', 2294, 22, 2294, 23),
woosh.Token(woosh.NAME, 'os', 2294, 23, 2294, 25),
woosh.Token(woosh.OP, ',', 2294, 25, 2294, 26),
woosh.Token(woosh.STRING, "'utime'", 2294, 27, 2294, 34),
woosh.Token(woosh.OP, ')', 2294, 34, 2294, 35),
woosh.Token(woosh.OP, ':', 2294, 35, 2294, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 2294, 36, 2295, 0),
woosh.Token(woosh.INDENT, ' ', 2295, 0, 2295, 12),
woosh.Token(woosh.NAME, 'return', 2295, 12, 2295, 18),
woosh.Token(woosh.NEWLINE, '\r\n', 2295, 18, 2296, 0),
woosh.Token(woosh.DEDENT, ' ', 2296, 0, 2296, 8),
woosh.Token(woosh.NAME, 'try', 2296, 8, 2296, 11),
woosh.Token(woosh.OP, ':', 2296, 11, 2296, 12),
woosh.Token(woosh.NEWLINE, '\r\n', 2296, 12, 2297, 0),
woosh.Token(woosh.INDENT, ' ', 2297, 0, 2297, 12),
woosh.Token(woosh.NAME, 'os', 2297, 12, 2297, 14),
woosh.Token(woosh.OP, '.', 2297, 14, 2297, 15),
woosh.Token(woosh.NAME, 'utime', 2297, 15, 2297, 20),
woosh.Token(woosh.OP, '(', 2297, 20, 2297, 21),
woosh.Token(woosh.NAME, 'targetpath', 2297, 21, 2297, 31),
woosh.Token(woosh.OP, ',', 2297, 31, 2297, 32),
woosh.Token(woosh.OP, '(', 2297, 33, 2297, 34),
woosh.Token(woosh.NAME, 'tarinfo', 2297, 34, 2297, 41),
woosh.Token(woosh.OP, '.', 2297, 41, 2297, 42),
woosh.Token(woosh.NAME, 'mtime', 2297, 42, 2297, 47),
woosh.Token(woosh.OP, ',', 2297, 47, 2297, 48),
woosh.Token(woosh.NAME, 'tarinfo', 2297, 49, 2297, 56),
woosh.Token(woosh.OP, '.', 2297, 56, 2297, 57),
woosh.Token(woosh.NAME, 'mtime', 2297, 57, 2297, 62),
woosh.Token(woosh.OP, ')', 2297, 62, 2297, 63),
woosh.Token(woosh.OP, ')', 2297, 63, 2297, 64),
woosh.Token(woosh.NEWLINE, '\r\n', 2297, 64, 2298, 0),
woosh.Token(woosh.DEDENT, ' ', 2298, 0, 2298, 8),
woosh.Token(woosh.NAME, 'except', 2298, 8, 2298, 14),
woosh.Token(woosh.NAME, 'OSError', 2298, 15, 2298, 22),
woosh.Token(woosh.OP, ':', 2298, 22, 2298, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 2298, 23, 2299, 0),
woosh.Token(woosh.INDENT, ' ', 2299, 0, 2299, 12),
woosh.Token(woosh.NAME, 'raise', 2299, 12, 2299, 17),
woosh.Token(woosh.NAME, 'ExtractError', 2299, 18, 2299, 30),
woosh.Token(woosh.OP, '(', 2299, 30, 2299, 31),
woosh.Token(woosh.STRING, '"could not change modification time"', 2299, 31, 2299, 67),
woosh.Token(woosh.OP, ')', 2299, 67, 2299, 68),
woosh.Token(woosh.NEWLINE, '\r\n', 2299, 68, 2300, 0),
woosh.Token(woosh.COMMENT, '#--------------------------------------------------------------------------', 2301, 4, 2301, 79),
woosh.Token(woosh.DEDENT, ' ', 2302, 0, 2302, 4),
woosh.Token(woosh.DEDENT, '', 2302, 4, 2302, 4),
woosh.Token(woosh.NAME, 'def', 2302, 4, 2302, 7),
woosh.Token(woosh.NAME, 'next', 2302, 8, 2302, 12),
woosh.Token(woosh.OP, '(', 2302, 12, 2302, 13),
woosh.Token(woosh.NAME, 'self', 2302, 13, 2302, 17),
woosh.Token(woosh.OP, ')', 2302, 17, 2302, 18),
woosh.Token(woosh.OP, ':', 2302, 18, 2302, 19),
woosh.Token(woosh.NEWLINE, '\r\n', 2302, 19, 2303, 0),
woosh.Token(woosh.INDENT, ' ', 2303, 0, 2303, 8),
woosh.Token(woosh.STRING, '"""Return the next member of the archive as a TarInfo object, when\r\n TarFile is opened for reading. Return None if there is no more\r\n available.\r\n """', 2303, 8, 2306, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 2306, 11, 2307, 0),
woosh.Token(woosh.NAME, 'self', 2307, 8, 2307, 12),
woosh.Token(woosh.OP, '.', 2307, 12, 2307, 13),
woosh.Token(woosh.NAME, '_check', 2307, 13, 2307, 19),
woosh.Token(woosh.OP, '(', 2307, 19, 2307, 20),
woosh.Token(woosh.STRING, '"ra"', 2307, 20, 2307, 24),
woosh.Token(woosh.OP, ')', 2307, 24, 2307, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 2307, 25, 2308, 0),
woosh.Token(woosh.NAME, 'if', 2308, 8, 2308, 10),
woosh.Token(woosh.NAME, 'self', 2308, 11, 2308, 15),
woosh.Token(woosh.OP, '.', 2308, 15, 2308, 16),
woosh.Token(woosh.NAME, 'firstmember', 2308, 16, 2308, 27),
woosh.Token(woosh.NAME, 'is', 2308, 28, 2308, 30),
woosh.Token(woosh.NAME, 'not', 2308, 31, 2308, 34),
woosh.Token(woosh.NAME, 'None', 2308, 35, 2308, 39),
woosh.Token(woosh.OP, ':', 2308, 39, 2308, 40),
woosh.Token(woosh.NEWLINE, '\r\n', 2308, 40, 2309, 0),
woosh.Token(woosh.INDENT, ' ', 2309, 0, 2309, 12),
woosh.Token(woosh.NAME, 'm', 2309, 12, 2309, 13),
woosh.Token(woosh.OP, '=', 2309, 14, 2309, 15),
woosh.Token(woosh.NAME, 'self', 2309, 16, 2309, 20),
woosh.Token(woosh.OP, '.', 2309, 20, 2309, 21),
woosh.Token(woosh.NAME, 'firstmember', 2309, 21, 2309, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 2309, 32, 2310, 0),
woosh.Token(woosh.NAME, 'self', 2310, 12, 2310, 16),
woosh.Token(woosh.OP, '.', 2310, 16, 2310, 17),
woosh.Token(woosh.NAME, 'firstmember', 2310, 17, 2310, 28),
woosh.Token(woosh.OP, '=', 2310, 29, 2310, 30),
woosh.Token(woosh.NAME, 'None', 2310, 31, 2310, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 2310, 35, 2311, 0),
woosh.Token(woosh.NAME, 'return', 2311, 12, 2311, 18),
woosh.Token(woosh.NAME, 'm', 2311, 19, 2311, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 2311, 20, 2312, 0),
woosh.Token(woosh.COMMENT, '# Advance the file pointer.', 2313, 8, 2313, 35),
woosh.Token(woosh.DEDENT, ' ', 2314, 0, 2314, 8),
woosh.Token(woosh.NAME, 'if', 2314, 8, 2314, 10),
woosh.Token(woosh.NAME, 'self', 2314, 11, 2314, 15),
woosh.Token(woosh.OP, '.', 2314, 15, 2314, 16),
woosh.Token(woosh.NAME, 'offset', 2314, 16, 2314, 22),
woosh.Token(woosh.OP, '!=', 2314, 23, 2314, 25),
woosh.Token(woosh.NAME, 'self', 2314, 26, 2314, 30),
woosh.Token(woosh.OP, '.', 2314, 30, 2314, 31),
woosh.Token(woosh.NAME, 'fileobj', 2314, 31, 2314, 38),
woosh.Token(woosh.OP, '.', 2314, 38, 2314, 39),
woosh.Token(woosh.NAME, 'tell', 2314, 39, 2314, 43),
woosh.Token(woosh.OP, '(', 2314, 43, 2314, 44),
woosh.Token(woosh.OP, ')', 2314, 44, 2314, 45),
woosh.Token(woosh.OP, ':', 2314, 45, 2314, 46),
woosh.Token(woosh.NEWLINE, '\r\n', 2314, 46, 2315, 0),
woosh.Token(woosh.INDENT, ' ', 2315, 0, 2315, 12),
woosh.Token(woosh.NAME, 'self', 2315, 12, 2315, 16),
woosh.Token(woosh.OP, '.', 2315, 16, 2315, 17),
woosh.Token(woosh.NAME, 'fileobj', 2315, 17, 2315, 24),
woosh.Token(woosh.OP, '.', 2315, 24, 2315, 25),
woosh.Token(woosh.NAME, 'seek', 2315, 25, 2315, 29),
woosh.Token(woosh.OP, '(', 2315, 29, 2315, 30),
woosh.Token(woosh.NAME, 'self', 2315, 30, 2315, 34),
woosh.Token(woosh.OP, '.', 2315, 34, 2315, 35),
woosh.Token(woosh.NAME, 'offset', 2315, 35, 2315, 41),
woosh.Token(woosh.OP, '-', 2315, 42, 2315, 43),
woosh.Token(woosh.NUMBER, '1', 2315, 44, 2315, 45),
woosh.Token(woosh.OP, ')', 2315, 45, 2315, 46),
woosh.Token(woosh.NEWLINE, '\r\n', 2315, 46, 2316, 0),
woosh.Token(woosh.NAME, 'if', 2316, 12, 2316, 14),
woosh.Token(woosh.NAME, 'not', 2316, 15, 2316, 18),
woosh.Token(woosh.NAME, 'self', 2316, 19, 2316, 23),
woosh.Token(woosh.OP, '.', 2316, 23, 2316, 24),
woosh.Token(woosh.NAME, 'fileobj', 2316, 24, 2316, 31),
woosh.Token(woosh.OP, '.', 2316, 31, 2316, 32),
woosh.Token(woosh.NAME, 'read', 2316, 32, 2316, 36),
woosh.Token(woosh.OP, '(', 2316, 36, 2316, 37),
woosh.Token(woosh.NUMBER, '1', 2316, 37, 2316, 38),
woosh.Token(woosh.OP, ')', 2316, 38, 2316, 39),
woosh.Token(woosh.OP, ':', 2316, 39, 2316, 40),
woosh.Token(woosh.NEWLINE, '\r\n', 2316, 40, 2317, 0),
woosh.Token(woosh.INDENT, ' ', 2317, 0, 2317, 16),
woosh.Token(woosh.NAME, 'raise', 2317, 16, 2317, 21),
woosh.Token(woosh.NAME, 'ReadError', 2317, 22, 2317, 31),
woosh.Token(woosh.OP, '(', 2317, 31, 2317, 32),
woosh.Token(woosh.STRING, '"unexpected end of data"', 2317, 32, 2317, 56),
woosh.Token(woosh.OP, ')', 2317, 56, 2317, 57),
woosh.Token(woosh.NEWLINE, '\r\n', 2317, 57, 2318, 0),
woosh.Token(woosh.COMMENT, '# Read the next block.', 2319, 8, 2319, 30),
woosh.Token(woosh.DEDENT, ' ', 2320, 0, 2320, 8),
woosh.Token(woosh.DEDENT, '', 2320, 8, 2320, 8),
woosh.Token(woosh.NAME, 'tarinfo', 2320, 8, 2320, 15),
woosh.Token(woosh.OP, '=', 2320, 16, 2320, 17),
woosh.Token(woosh.NAME, 'None', 2320, 18, 2320, 22),
woosh.Token(woosh.NEWLINE, '\r\n', 2320, 22, 2321, 0),
woosh.Token(woosh.NAME, 'while', 2321, 8, 2321, 13),
woosh.Token(woosh.NAME, 'True', 2321, 14, 2321, 18),
woosh.Token(woosh.OP, ':', 2321, 18, 2321, 19),
woosh.Token(woosh.NEWLINE, '\r\n', 2321, 19, 2322, 0),
woosh.Token(woosh.INDENT, ' ', 2322, 0, 2322, 12),
woosh.Token(woosh.NAME, 'try', 2322, 12, 2322, 15),
woosh.Token(woosh.OP, ':', 2322, 15, 2322, 16),
woosh.Token(woosh.NEWLINE, '\r\n', 2322, 16, 2323, 0),
woosh.Token(woosh.INDENT, ' ', 2323, 0, 2323, 16),
woosh.Token(woosh.NAME, 'tarinfo', 2323, 16, 2323, 23),
woosh.Token(woosh.OP, '=', 2323, 24, 2323, 25),
woosh.Token(woosh.NAME, 'self', 2323, 26, 2323, 30),
woosh.Token(woosh.OP, '.', 2323, 30, 2323, 31),
woosh.Token(woosh.NAME, 'tarinfo', 2323, 31, 2323, 38),
woosh.Token(woosh.OP, '.', 2323, 38, 2323, 39),
woosh.Token(woosh.NAME, 'fromtarfile', 2323, 39, 2323, 50),
woosh.Token(woosh.OP, '(', 2323, 50, 2323, 51),
woosh.Token(woosh.NAME, 'self', 2323, 51, 2323, 55),
woosh.Token(woosh.OP, ')', 2323, 55, 2323, 56),
woosh.Token(woosh.NEWLINE, '\r\n', 2323, 56, 2324, 0),
woosh.Token(woosh.DEDENT, ' ', 2324, 0, 2324, 12),
woosh.Token(woosh.NAME, 'except', 2324, 12, 2324, 18),
woosh.Token(woosh.NAME, 'EOFHeaderError', 2324, 19, 2324, 33),
woosh.Token(woosh.NAME, 'as', 2324, 34, 2324, 36),
woosh.Token(woosh.NAME, 'e', 2324, 37, 2324, 38),
woosh.Token(woosh.OP, ':', 2324, 38, 2324, 39),
woosh.Token(woosh.NEWLINE, '\r\n', 2324, 39, 2325, 0),
woosh.Token(woosh.INDENT, ' ', 2325, 0, 2325, 16),
woosh.Token(woosh.NAME, 'if', 2325, 16, 2325, 18),
woosh.Token(woosh.NAME, 'self', 2325, 19, 2325, 23),
woosh.Token(woosh.OP, '.', 2325, 23, 2325, 24),
woosh.Token(woosh.NAME, 'ignore_zeros', 2325, 24, 2325, 36),
woosh.Token(woosh.OP, ':', 2325, 36, 2325, 37),
woosh.Token(woosh.NEWLINE, '\r\n', 2325, 37, 2326, 0),
woosh.Token(woosh.INDENT, ' ', 2326, 0, 2326, 20),
woosh.Token(woosh.NAME, 'self', 2326, 20, 2326, 24),
woosh.Token(woosh.OP, '.', 2326, 24, 2326, 25),
woosh.Token(woosh.NAME, '_dbg', 2326, 25, 2326, 29),
woosh.Token(woosh.OP, '(', 2326, 29, 2326, 30),
woosh.Token(woosh.NUMBER, '2', 2326, 30, 2326, 31),
woosh.Token(woosh.OP, ',', 2326, 31, 2326, 32),
woosh.Token(woosh.STRING, '"0x%X: %s"', 2326, 33, 2326, 43),
woosh.Token(woosh.OP, '%', 2326, 44, 2326, 45),
woosh.Token(woosh.OP, '(', 2326, 46, 2326, 47),
woosh.Token(woosh.NAME, 'self', 2326, 47, 2326, 51),
woosh.Token(woosh.OP, '.', 2326, 51, 2326, 52),
woosh.Token(woosh.NAME, 'offset', 2326, 52, 2326, 58),
woosh.Token(woosh.OP, ',', 2326, 58, 2326, 59),
woosh.Token(woosh.NAME, 'e', 2326, 60, 2326, 61),
woosh.Token(woosh.OP, ')', 2326, 61, 2326, 62),
woosh.Token(woosh.OP, ')', 2326, 62, 2326, 63),
woosh.Token(woosh.NEWLINE, '\r\n', 2326, 63, 2327, 0),
woosh.Token(woosh.NAME, 'self', 2327, 20, 2327, 24),
woosh.Token(woosh.OP, '.', 2327, 24, 2327, 25),
woosh.Token(woosh.NAME, 'offset', 2327, 25, 2327, 31),
woosh.Token(woosh.OP, '+=', 2327, 32, 2327, 34),
woosh.Token(woosh.NAME, 'BLOCKSIZE', 2327, 35, 2327, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 2327, 44, 2328, 0),
woosh.Token(woosh.NAME, 'continue', 2328, 20, 2328, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 2328, 28, 2329, 0),
woosh.Token(woosh.DEDENT, ' ', 2329, 0, 2329, 12),
woosh.Token(woosh.DEDENT, '', 2329, 12, 2329, 12),
woosh.Token(woosh.NAME, 'except', 2329, 12, 2329, 18),
woosh.Token(woosh.NAME, 'InvalidHeaderError', 2329, 19, 2329, 37),
woosh.Token(woosh.NAME, 'as', 2329, 38, 2329, 40),
woosh.Token(woosh.NAME, 'e', 2329, 41, 2329, 42),
woosh.Token(woosh.OP, ':', 2329, 42, 2329, 43),
woosh.Token(woosh.NEWLINE, '\r\n', 2329, 43, 2330, 0),
woosh.Token(woosh.INDENT, ' ', 2330, 0, 2330, 16),
woosh.Token(woosh.NAME, 'if', 2330, 16, 2330, 18),
woosh.Token(woosh.NAME, 'self', 2330, 19, 2330, 23),
woosh.Token(woosh.OP, '.', 2330, 23, 2330, 24),
woosh.Token(woosh.NAME, 'ignore_zeros', 2330, 24, 2330, 36),
woosh.Token(woosh.OP, ':', 2330, 36, 2330, 37),
woosh.Token(woosh.NEWLINE, '\r\n', 2330, 37, 2331, 0),
woosh.Token(woosh.INDENT, ' ', 2331, 0, 2331, 20),
woosh.Token(woosh.NAME, 'self', 2331, 20, 2331, 24),
woosh.Token(woosh.OP, '.', 2331, 24, 2331, 25),
woosh.Token(woosh.NAME, '_dbg', 2331, 25, 2331, 29),
woosh.Token(woosh.OP, '(', 2331, 29, 2331, 30),
woosh.Token(woosh.NUMBER, '2', 2331, 30, 2331, 31),
woosh.Token(woosh.OP, ',', 2331, 31, 2331, 32),
woosh.Token(woosh.STRING, '"0x%X: %s"', 2331, 33, 2331, 43),
woosh.Token(woosh.OP, '%', 2331, 44, 2331, 45),
woosh.Token(woosh.OP, '(', 2331, 46, 2331, 47),
woosh.Token(woosh.NAME, 'self', 2331, 47, 2331, 51),
woosh.Token(woosh.OP, '.', 2331, 51, 2331, 52),
woosh.Token(woosh.NAME, 'offset', 2331, 52, 2331, 58),
woosh.Token(woosh.OP, ',', 2331, 58, 2331, 59),
woosh.Token(woosh.NAME, 'e', 2331, 60, 2331, 61),
woosh.Token(woosh.OP, ')', 2331, 61, 2331, 62),
woosh.Token(woosh.OP, ')', 2331, 62, 2331, 63),
woosh.Token(woosh.NEWLINE, '\r\n', 2331, 63, 2332, 0),
woosh.Token(woosh.NAME, 'self', 2332, 20, 2332, 24),
woosh.Token(woosh.OP, '.', 2332, 24, 2332, 25),
woosh.Token(woosh.NAME, 'offset', 2332, 25, 2332, 31),
woosh.Token(woosh.OP, '+=', 2332, 32, 2332, 34),
woosh.Token(woosh.NAME, 'BLOCKSIZE', 2332, 35, 2332, 44),
woosh.Token(woosh.NEWLINE, '\r\n', 2332, 44, 2333, 0),
woosh.Token(woosh.NAME, 'continue', 2333, 20, 2333, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 2333, 28, 2334, 0),
woosh.Token(woosh.DEDENT, ' ', 2334, 0, 2334, 16),
woosh.Token(woosh.NAME, 'elif', 2334, 16, 2334, 20),
woosh.Token(woosh.NAME, 'self', 2334, 21, 2334, 25),
woosh.Token(woosh.OP, '.', 2334, 25, 2334, 26),
woosh.Token(woosh.NAME, 'offset', 2334, 26, 2334, 32),
woosh.Token(woosh.OP, '==', 2334, 33, 2334, 35),
woosh.Token(woosh.NUMBER, '0', 2334, 36, 2334, 37),
woosh.Token(woosh.OP, ':', 2334, 37, 2334, 38),
woosh.Token(woosh.NEWLINE, '\r\n', 2334, 38, 2335, 0),
woosh.Token(woosh.INDENT, ' ', 2335, 0, 2335, 20),
woosh.Token(woosh.NAME, 'raise', 2335, 20, 2335, 25),
woosh.Token(woosh.NAME, 'ReadError', 2335, 26, 2335, 35),
woosh.Token(woosh.OP, '(', 2335, 35, 2335, 36),
woosh.Token(woosh.NAME, 'str', 2335, 36, 2335, 39),
woosh.Token(woosh.OP, '(', 2335, 39, 2335, 40),
woosh.Token(woosh.NAME, 'e', 2335, 40, 2335, 41),
woosh.Token(woosh.OP, ')', 2335, 41, 2335, 42),
woosh.Token(woosh.OP, ')', 2335, 42, 2335, 43),
woosh.Token(woosh.NEWLINE, '\r\n', 2335, 43, 2336, 0),
woosh.Token(woosh.DEDENT, ' ', 2336, 0, 2336, 12),
woosh.Token(woosh.DEDENT, '', 2336, 12, 2336, 12),
woosh.Token(woosh.NAME, 'except', 2336, 12, 2336, 18),
woosh.Token(woosh.NAME, 'EmptyHeaderError', 2336, 19, 2336, 35),
woosh.Token(woosh.OP, ':', 2336, 35, 2336, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 2336, 36, 2337, 0),
woosh.Token(woosh.INDENT, ' ', 2337, 0, 2337, 16),
woosh.Token(woosh.NAME, 'if', 2337, 16, 2337, 18),
woosh.Token(woosh.NAME, 'self', 2337, 19, 2337, 23),
woosh.Token(woosh.OP, '.', 2337, 23, 2337, 24),
woosh.Token(woosh.NAME, 'offset', 2337, 24, 2337, 30),
woosh.Token(woosh.OP, '==', 2337, 31, 2337, 33),
woosh.Token(woosh.NUMBER, '0', 2337, 34, 2337, 35),
woosh.Token(woosh.OP, ':', 2337, 35, 2337, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 2337, 36, 2338, 0),
woosh.Token(woosh.INDENT, ' ', 2338, 0, 2338, 20),
woosh.Token(woosh.NAME, 'raise', 2338, 20, 2338, 25),
woosh.Token(woosh.NAME, 'ReadError', 2338, 26, 2338, 35),
woosh.Token(woosh.OP, '(', 2338, 35, 2338, 36),
woosh.Token(woosh.STRING, '"empty file"', 2338, 36, 2338, 48),
woosh.Token(woosh.OP, ')', 2338, 48, 2338, 49),
woosh.Token(woosh.NEWLINE, '\r\n', 2338, 49, 2339, 0),
woosh.Token(woosh.DEDENT, ' ', 2339, 0, 2339, 12),
woosh.Token(woosh.DEDENT, '', 2339, 12, 2339, 12),
woosh.Token(woosh.NAME, 'except', 2339, 12, 2339, 18),
woosh.Token(woosh.NAME, 'TruncatedHeaderError', 2339, 19, 2339, 39),
woosh.Token(woosh.NAME, 'as', 2339, 40, 2339, 42),
woosh.Token(woosh.NAME, 'e', 2339, 43, 2339, 44),
woosh.Token(woosh.OP, ':', 2339, 44, 2339, 45),
woosh.Token(woosh.NEWLINE, '\r\n', 2339, 45, 2340, 0),
woosh.Token(woosh.INDENT, ' ', 2340, 0, 2340, 16),
woosh.Token(woosh.NAME, 'if', 2340, 16, 2340, 18),
woosh.Token(woosh.NAME, 'self', 2340, 19, 2340, 23),
woosh.Token(woosh.OP, '.', 2340, 23, 2340, 24),
woosh.Token(woosh.NAME, 'offset', 2340, 24, 2340, 30),
woosh.Token(woosh.OP, '==', 2340, 31, 2340, 33),
woosh.Token(woosh.NUMBER, '0', 2340, 34, 2340, 35),
woosh.Token(woosh.OP, ':', 2340, 35, 2340, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 2340, 36, 2341, 0),
woosh.Token(woosh.INDENT, ' ', 2341, 0, 2341, 20),
woosh.Token(woosh.NAME, 'raise', 2341, 20, 2341, 25),
woosh.Token(woosh.NAME, 'ReadError', 2341, 26, 2341, 35),
woosh.Token(woosh.OP, '(', 2341, 35, 2341, 36),
woosh.Token(woosh.NAME, 'str', 2341, 36, 2341, 39),
woosh.Token(woosh.OP, '(', 2341, 39, 2341, 40),
woosh.Token(woosh.NAME, 'e', 2341, 40, 2341, 41),
woosh.Token(woosh.OP, ')', 2341, 41, 2341, 42),
woosh.Token(woosh.OP, ')', 2341, 42, 2341, 43),
woosh.Token(woosh.NEWLINE, '\r\n', 2341, 43, 2342, 0),
woosh.Token(woosh.DEDENT, ' ', 2342, 0, 2342, 12),
woosh.Token(woosh.DEDENT, '', 2342, 12, 2342, 12),
woosh.Token(woosh.NAME, 'except', 2342, 12, 2342, 18),
woosh.Token(woosh.NAME, 'SubsequentHeaderError', 2342, 19, 2342, 40),
woosh.Token(woosh.NAME, 'as', 2342, 41, 2342, 43),
woosh.Token(woosh.NAME, 'e', 2342, 44, 2342, 45),
woosh.Token(woosh.OP, ':', 2342, 45, 2342, 46),
woosh.Token(woosh.NEWLINE, '\r\n', 2342, 46, 2343, 0),
woosh.Token(woosh.INDENT, ' ', 2343, 0, 2343, 16),
woosh.Token(woosh.NAME, 'raise', 2343, 16, 2343, 21),
woosh.Token(woosh.NAME, 'ReadError', 2343, 22, 2343, 31),
woosh.Token(woosh.OP, '(', 2343, 31, 2343, 32),
woosh.Token(woosh.NAME, 'str', 2343, 32, 2343, 35),
woosh.Token(woosh.OP, '(', 2343, 35, 2343, 36),
woosh.Token(woosh.NAME, 'e', 2343, 36, 2343, 37),
woosh.Token(woosh.OP, ')', 2343, 37, 2343, 38),
woosh.Token(woosh.OP, ')', 2343, 38, 2343, 39),
woosh.Token(woosh.NEWLINE, '\r\n', 2343, 39, 2344, 0),
woosh.Token(woosh.DEDENT, ' ', 2344, 0, 2344, 12),
woosh.Token(woosh.NAME, 'break', 2344, 12, 2344, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 2344, 17, 2345, 0),
woosh.Token(woosh.DEDENT, ' ', 2346, 0, 2346, 8),
woosh.Token(woosh.NAME, 'if', 2346, 8, 2346, 10),
woosh.Token(woosh.NAME, 'tarinfo', 2346, 11, 2346, 18),
woosh.Token(woosh.NAME, 'is', 2346, 19, 2346, 21),
woosh.Token(woosh.NAME, 'not', 2346, 22, 2346, 25),
woosh.Token(woosh.NAME, 'None', 2346, 26, 2346, 30),
woosh.Token(woosh.OP, ':', 2346, 30, 2346, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 2346, 31, 2347, 0),
woosh.Token(woosh.INDENT, ' ', 2347, 0, 2347, 12),
woosh.Token(woosh.NAME, 'self', 2347, 12, 2347, 16),
woosh.Token(woosh.OP, '.', 2347, 16, 2347, 17),
woosh.Token(woosh.NAME, 'members', 2347, 17, 2347, 24),
woosh.Token(woosh.OP, '.', 2347, 24, 2347, 25),
woosh.Token(woosh.NAME, 'append', 2347, 25, 2347, 31),
woosh.Token(woosh.OP, '(', 2347, 31, 2347, 32),
woosh.Token(woosh.NAME, 'tarinfo', 2347, 32, 2347, 39),
woosh.Token(woosh.OP, ')', 2347, 39, 2347, 40),
woosh.Token(woosh.NEWLINE, '\r\n', 2347, 40, 2348, 0),
woosh.Token(woosh.DEDENT, ' ', 2348, 0, 2348, 8),
woosh.Token(woosh.NAME, 'else', 2348, 8, 2348, 12),
woosh.Token(woosh.OP, ':', 2348, 12, 2348, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 2348, 13, 2349, 0),
woosh.Token(woosh.INDENT, ' ', 2349, 0, 2349, 12),
woosh.Token(woosh.NAME, 'self', 2349, 12, 2349, 16),
woosh.Token(woosh.OP, '.', 2349, 16, 2349, 17),
woosh.Token(woosh.NAME, '_loaded', 2349, 17, 2349, 24),
woosh.Token(woosh.OP, '=', 2349, 25, 2349, 26),
woosh.Token(woosh.NAME, 'True', 2349, 27, 2349, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 2349, 31, 2350, 0),
woosh.Token(woosh.DEDENT, ' ', 2351, 0, 2351, 8),
woosh.Token(woosh.NAME, 'return', 2351, 8, 2351, 14),
woosh.Token(woosh.NAME, 'tarinfo', 2351, 15, 2351, 22),
woosh.Token(woosh.NEWLINE, '\r\n', 2351, 22, 2352, 0),
woosh.Token(woosh.COMMENT, '#--------------------------------------------------------------------------', 2353, 4, 2353, 79),
woosh.Token(woosh.COMMENT, '# Little helper methods:', 2354, 4, 2354, 28),
woosh.Token(woosh.DEDENT, ' ', 2356, 0, 2356, 4),
woosh.Token(woosh.NAME, 'def', 2356, 4, 2356, 7),
woosh.Token(woosh.NAME, '_getmember', 2356, 8, 2356, 18),
woosh.Token(woosh.OP, '(', 2356, 18, 2356, 19),
woosh.Token(woosh.NAME, 'self', 2356, 19, 2356, 23),
woosh.Token(woosh.OP, ',', 2356, 23, 2356, 24),
woosh.Token(woosh.NAME, 'name', 2356, 25, 2356, 29),
woosh.Token(woosh.OP, ',', 2356, 29, 2356, 30),
woosh.Token(woosh.NAME, 'tarinfo', 2356, 31, 2356, 38),
woosh.Token(woosh.OP, '=', 2356, 38, 2356, 39),
woosh.Token(woosh.NAME, 'None', 2356, 39, 2356, 43),
woosh.Token(woosh.OP, ',', 2356, 43, 2356, 44),
woosh.Token(woosh.NAME, 'normalize', 2356, 45, 2356, 54),
woosh.Token(woosh.OP, '=', 2356, 54, 2356, 55),
woosh.Token(woosh.NAME, 'False', 2356, 55, 2356, 60),
woosh.Token(woosh.OP, ')', 2356, 60, 2356, 61),
woosh.Token(woosh.OP, ':', 2356, 61, 2356, 62),
woosh.Token(woosh.NEWLINE, '\r\n', 2356, 62, 2357, 0),
woosh.Token(woosh.INDENT, ' ', 2357, 0, 2357, 8),
woosh.Token(woosh.STRING, '"""Find an archive member by name from bottom to top.\r\n If tarinfo is given, it is used as the starting point.\r\n """', 2357, 8, 2359, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 2359, 11, 2360, 0),
woosh.Token(woosh.COMMENT, '# Ensure that all members have been loaded.', 2360, 8, 2360, 51),
woosh.Token(woosh.NAME, 'members', 2361, 8, 2361, 15),
woosh.Token(woosh.OP, '=', 2361, 16, 2361, 17),
woosh.Token(woosh.NAME, 'self', 2361, 18, 2361, 22),
woosh.Token(woosh.OP, '.', 2361, 22, 2361, 23),
woosh.Token(woosh.NAME, 'getmembers', 2361, 23, 2361, 33),
woosh.Token(woosh.OP, '(', 2361, 33, 2361, 34),
woosh.Token(woosh.OP, ')', 2361, 34, 2361, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 2361, 35, 2362, 0),
woosh.Token(woosh.COMMENT, '# Limit the member search list up to tarinfo.', 2363, 8, 2363, 53),
woosh.Token(woosh.NAME, 'if', 2364, 8, 2364, 10),
woosh.Token(woosh.NAME, 'tarinfo', 2364, 11, 2364, 18),
woosh.Token(woosh.NAME, 'is', 2364, 19, 2364, 21),
woosh.Token(woosh.NAME, 'not', 2364, 22, 2364, 25),
woosh.Token(woosh.NAME, 'None', 2364, 26, 2364, 30),
woosh.Token(woosh.OP, ':', 2364, 30, 2364, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 2364, 31, 2365, 0),
woosh.Token(woosh.INDENT, ' ', 2365, 0, 2365, 12),
woosh.Token(woosh.NAME, 'members', 2365, 12, 2365, 19),
woosh.Token(woosh.OP, '=', 2365, 20, 2365, 21),
woosh.Token(woosh.NAME, 'members', 2365, 22, 2365, 29),
woosh.Token(woosh.OP, '[', 2365, 29, 2365, 30),
woosh.Token(woosh.OP, ':', 2365, 30, 2365, 31),
woosh.Token(woosh.NAME, 'members', 2365, 31, 2365, 38),
woosh.Token(woosh.OP, '.', 2365, 38, 2365, 39),
woosh.Token(woosh.NAME, 'index', 2365, 39, 2365, 44),
woosh.Token(woosh.OP, '(', 2365, 44, 2365, 45),
woosh.Token(woosh.NAME, 'tarinfo', 2365, 45, 2365, 52),
woosh.Token(woosh.OP, ')', 2365, 52, 2365, 53),
woosh.Token(woosh.OP, ']', 2365, 53, 2365, 54),
woosh.Token(woosh.NEWLINE, '\r\n', 2365, 54, 2366, 0),
woosh.Token(woosh.DEDENT, ' ', 2367, 0, 2367, 8),
woosh.Token(woosh.NAME, 'if', 2367, 8, 2367, 10),
woosh.Token(woosh.NAME, 'normalize', 2367, 11, 2367, 20),
woosh.Token(woosh.OP, ':', 2367, 20, 2367, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 2367, 21, 2368, 0),
woosh.Token(woosh.INDENT, ' ', 2368, 0, 2368, 12),
woosh.Token(woosh.NAME, 'name', 2368, 12, 2368, 16),
woosh.Token(woosh.OP, '=', 2368, 17, 2368, 18),
woosh.Token(woosh.NAME, 'os', 2368, 19, 2368, 21),
woosh.Token(woosh.OP, '.', 2368, 21, 2368, 22),
woosh.Token(woosh.NAME, 'path', 2368, 22, 2368, 26),
woosh.Token(woosh.OP, '.', 2368, 26, 2368, 27),
woosh.Token(woosh.NAME, 'normpath', 2368, 27, 2368, 35),
woosh.Token(woosh.OP, '(', 2368, 35, 2368, 36),
woosh.Token(woosh.NAME, 'name', 2368, 36, 2368, 40),
woosh.Token(woosh.OP, ')', 2368, 40, 2368, 41),
woosh.Token(woosh.NEWLINE, '\r\n', 2368, 41, 2369, 0),
woosh.Token(woosh.DEDENT, ' ', 2370, 0, 2370, 8),
woosh.Token(woosh.NAME, 'for', 2370, 8, 2370, 11),
woosh.Token(woosh.NAME, 'member', 2370, 12, 2370, 18),
woosh.Token(woosh.NAME, 'in', 2370, 19, 2370, 21),
woosh.Token(woosh.NAME, 'reversed', 2370, 22, 2370, 30),
woosh.Token(woosh.OP, '(', 2370, 30, 2370, 31),
woosh.Token(woosh.NAME, 'members', 2370, 31, 2370, 38),
woosh.Token(woosh.OP, ')', 2370, 38, 2370, 39),
woosh.Token(woosh.OP, ':', 2370, 39, 2370, 40),
woosh.Token(woosh.NEWLINE, '\r\n', 2370, 40, 2371, 0),
woosh.Token(woosh.INDENT, ' ', 2371, 0, 2371, 12),
woosh.Token(woosh.NAME, 'if', 2371, 12, 2371, 14),
woosh.Token(woosh.NAME, 'normalize', 2371, 15, 2371, 24),
woosh.Token(woosh.OP, ':', 2371, 24, 2371, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 2371, 25, 2372, 0),
woosh.Token(woosh.INDENT, ' ', 2372, 0, 2372, 16),
woosh.Token(woosh.NAME, 'member_name', 2372, 16, 2372, 27),
woosh.Token(woosh.OP, '=', 2372, 28, 2372, 29),
woosh.Token(woosh.NAME, 'os', 2372, 30, 2372, 32),
woosh.Token(woosh.OP, '.', 2372, 32, 2372, 33),
woosh.Token(woosh.NAME, 'path', 2372, 33, 2372, 37),
woosh.Token(woosh.OP, '.', 2372, 37, 2372, 38),
woosh.Token(woosh.NAME, 'normpath', 2372, 38, 2372, 46),
woosh.Token(woosh.OP, '(', 2372, 46, 2372, 47),
woosh.Token(woosh.NAME, 'member', 2372, 47, 2372, 53),
woosh.Token(woosh.OP, '.', 2372, 53, 2372, 54),
woosh.Token(woosh.NAME, 'name', 2372, 54, 2372, 58),
woosh.Token(woosh.OP, ')', 2372, 58, 2372, 59),
woosh.Token(woosh.NEWLINE, '\r\n', 2372, 59, 2373, 0),
woosh.Token(woosh.DEDENT, ' ', 2373, 0, 2373, 12),
woosh.Token(woosh.NAME, 'else', 2373, 12, 2373, 16),
woosh.Token(woosh.OP, ':', 2373, 16, 2373, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 2373, 17, 2374, 0),
woosh.Token(woosh.INDENT, ' ', 2374, 0, 2374, 16),
woosh.Token(woosh.NAME, 'member_name', 2374, 16, 2374, 27),
woosh.Token(woosh.OP, '=', 2374, 28, 2374, 29),
woosh.Token(woosh.NAME, 'member', 2374, 30, 2374, 36),
woosh.Token(woosh.OP, '.', 2374, 36, 2374, 37),
woosh.Token(woosh.NAME, 'name', 2374, 37, 2374, 41),
woosh.Token(woosh.NEWLINE, '\r\n', 2374, 41, 2375, 0),
woosh.Token(woosh.DEDENT, ' ', 2376, 0, 2376, 12),
woosh.Token(woosh.NAME, 'if', 2376, 12, 2376, 14),
woosh.Token(woosh.NAME, 'name', 2376, 15, 2376, 19),
woosh.Token(woosh.OP, '==', 2376, 20, 2376, 22),
woosh.Token(woosh.NAME, 'member_name', 2376, 23, 2376, 34),
woosh.Token(woosh.OP, ':', 2376, 34, 2376, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 2376, 35, 2377, 0),
woosh.Token(woosh.INDENT, ' ', 2377, 0, 2377, 16),
woosh.Token(woosh.NAME, 'return', 2377, 16, 2377, 22),
woosh.Token(woosh.NAME, 'member', 2377, 23, 2377, 29),
woosh.Token(woosh.NEWLINE, '\r\n', 2377, 29, 2378, 0),
woosh.Token(woosh.DEDENT, ' ', 2379, 0, 2379, 4),
woosh.Token(woosh.DEDENT, '', 2379, 4, 2379, 4),
woosh.Token(woosh.DEDENT, '', 2379, 4, 2379, 4),
woosh.Token(woosh.NAME, 'def', 2379, 4, 2379, 7),
woosh.Token(woosh.NAME, '_load', 2379, 8, 2379, 13),
woosh.Token(woosh.OP, '(', 2379, 13, 2379, 14),
woosh.Token(woosh.NAME, 'self', 2379, 14, 2379, 18),
woosh.Token(woosh.OP, ')', 2379, 18, 2379, 19),
woosh.Token(woosh.OP, ':', 2379, 19, 2379, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 2379, 20, 2380, 0),
woosh.Token(woosh.INDENT, ' ', 2380, 0, 2380, 8),
woosh.Token(woosh.STRING, '"""Read through the entire archive file and look for readable\r\n members.\r\n """', 2380, 8, 2382, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 2382, 11, 2383, 0),
woosh.Token(woosh.NAME, 'while', 2383, 8, 2383, 13),
woosh.Token(woosh.NAME, 'True', 2383, 14, 2383, 18),
woosh.Token(woosh.OP, ':', 2383, 18, 2383, 19),
woosh.Token(woosh.NEWLINE, '\r\n', 2383, 19, 2384, 0),
woosh.Token(woosh.INDENT, ' ', 2384, 0, 2384, 12),
woosh.Token(woosh.NAME, 'tarinfo', 2384, 12, 2384, 19),
woosh.Token(woosh.OP, '=', 2384, 20, 2384, 21),
woosh.Token(woosh.NAME, 'self', 2384, 22, 2384, 26),
woosh.Token(woosh.OP, '.', 2384, 26, 2384, 27),
woosh.Token(woosh.NAME, 'next', 2384, 27, 2384, 31),
woosh.Token(woosh.OP, '(', 2384, 31, 2384, 32),
woosh.Token(woosh.OP, ')', 2384, 32, 2384, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 2384, 33, 2385, 0),
woosh.Token(woosh.NAME, 'if', 2385, 12, 2385, 14),
woosh.Token(woosh.NAME, 'tarinfo', 2385, 15, 2385, 22),
woosh.Token(woosh.NAME, 'is', 2385, 23, 2385, 25),
woosh.Token(woosh.NAME, 'None', 2385, 26, 2385, 30),
woosh.Token(woosh.OP, ':', 2385, 30, 2385, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 2385, 31, 2386, 0),
woosh.Token(woosh.INDENT, ' ', 2386, 0, 2386, 16),
woosh.Token(woosh.NAME, 'break', 2386, 16, 2386, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 2386, 21, 2387, 0),
woosh.Token(woosh.DEDENT, ' ', 2387, 0, 2387, 8),
woosh.Token(woosh.DEDENT, '', 2387, 8, 2387, 8),
woosh.Token(woosh.NAME, 'self', 2387, 8, 2387, 12),
woosh.Token(woosh.OP, '.', 2387, 12, 2387, 13),
woosh.Token(woosh.NAME, '_loaded', 2387, 13, 2387, 20),
woosh.Token(woosh.OP, '=', 2387, 21, 2387, 22),
woosh.Token(woosh.NAME, 'True', 2387, 23, 2387, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 2387, 27, 2388, 0),
woosh.Token(woosh.DEDENT, ' ', 2389, 0, 2389, 4),
woosh.Token(woosh.NAME, 'def', 2389, 4, 2389, 7),
woosh.Token(woosh.NAME, '_check', 2389, 8, 2389, 14),
woosh.Token(woosh.OP, '(', 2389, 14, 2389, 15),
woosh.Token(woosh.NAME, 'self', 2389, 15, 2389, 19),
woosh.Token(woosh.OP, ',', 2389, 19, 2389, 20),
woosh.Token(woosh.NAME, 'mode', 2389, 21, 2389, 25),
woosh.Token(woosh.OP, '=', 2389, 25, 2389, 26),
woosh.Token(woosh.NAME, 'None', 2389, 26, 2389, 30),
woosh.Token(woosh.OP, ')', 2389, 30, 2389, 31),
woosh.Token(woosh.OP, ':', 2389, 31, 2389, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 2389, 32, 2390, 0),
woosh.Token(woosh.INDENT, ' ', 2390, 0, 2390, 8),
woosh.Token(woosh.STRING, '"""Check if TarFile is still open, and if the operation\'s mode\r\n corresponds to TarFile\'s mode.\r\n """', 2390, 8, 2392, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 2392, 11, 2393, 0),
woosh.Token(woosh.NAME, 'if', 2393, 8, 2393, 10),
woosh.Token(woosh.NAME, 'self', 2393, 11, 2393, 15),
woosh.Token(woosh.OP, '.', 2393, 15, 2393, 16),
woosh.Token(woosh.NAME, 'closed', 2393, 16, 2393, 22),
woosh.Token(woosh.OP, ':', 2393, 22, 2393, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 2393, 23, 2394, 0),
woosh.Token(woosh.INDENT, ' ', 2394, 0, 2394, 12),
woosh.Token(woosh.NAME, 'raise', 2394, 12, 2394, 17),
woosh.Token(woosh.NAME, 'OSError', 2394, 18, 2394, 25),
woosh.Token(woosh.OP, '(', 2394, 25, 2394, 26),
woosh.Token(woosh.STRING, '"%s is closed"', 2394, 26, 2394, 40),
woosh.Token(woosh.OP, '%', 2394, 41, 2394, 42),
woosh.Token(woosh.NAME, 'self', 2394, 43, 2394, 47),
woosh.Token(woosh.OP, '.', 2394, 47, 2394, 48),
woosh.Token(woosh.NAME, '__class__', 2394, 48, 2394, 57),
woosh.Token(woosh.OP, '.', 2394, 57, 2394, 58),
woosh.Token(woosh.NAME, '__name__', 2394, 58, 2394, 66),
woosh.Token(woosh.OP, ')', 2394, 66, 2394, 67),
woosh.Token(woosh.NEWLINE, '\r\n', 2394, 67, 2395, 0),
woosh.Token(woosh.DEDENT, ' ', 2395, 0, 2395, 8),
woosh.Token(woosh.NAME, 'if', 2395, 8, 2395, 10),
woosh.Token(woosh.NAME, 'mode', 2395, 11, 2395, 15),
woosh.Token(woosh.NAME, 'is', 2395, 16, 2395, 18),
woosh.Token(woosh.NAME, 'not', 2395, 19, 2395, 22),
woosh.Token(woosh.NAME, 'None', 2395, 23, 2395, 27),
woosh.Token(woosh.NAME, 'and', 2395, 28, 2395, 31),
woosh.Token(woosh.NAME, 'self', 2395, 32, 2395, 36),
woosh.Token(woosh.OP, '.', 2395, 36, 2395, 37),
woosh.Token(woosh.NAME, 'mode', 2395, 37, 2395, 41),
woosh.Token(woosh.NAME, 'not', 2395, 42, 2395, 45),
woosh.Token(woosh.NAME, 'in', 2395, 46, 2395, 48),
woosh.Token(woosh.NAME, 'mode', 2395, 49, 2395, 53),
woosh.Token(woosh.OP, ':', 2395, 53, 2395, 54),
woosh.Token(woosh.NEWLINE, '\r\n', 2395, 54, 2396, 0),
woosh.Token(woosh.INDENT, ' ', 2396, 0, 2396, 12),
woosh.Token(woosh.NAME, 'raise', 2396, 12, 2396, 17),
woosh.Token(woosh.NAME, 'OSError', 2396, 18, 2396, 25),
woosh.Token(woosh.OP, '(', 2396, 25, 2396, 26),
woosh.Token(woosh.STRING, '"bad operation for mode %r"', 2396, 26, 2396, 53),
woosh.Token(woosh.OP, '%', 2396, 54, 2396, 55),
woosh.Token(woosh.NAME, 'self', 2396, 56, 2396, 60),
woosh.Token(woosh.OP, '.', 2396, 60, 2396, 61),
woosh.Token(woosh.NAME, 'mode', 2396, 61, 2396, 65),
woosh.Token(woosh.OP, ')', 2396, 65, 2396, 66),
woosh.Token(woosh.NEWLINE, '\r\n', 2396, 66, 2397, 0),
woosh.Token(woosh.DEDENT, ' ', 2398, 0, 2398, 4),
woosh.Token(woosh.DEDENT, '', 2398, 4, 2398, 4),
woosh.Token(woosh.NAME, 'def', 2398, 4, 2398, 7),
woosh.Token(woosh.NAME, '_find_link_target', 2398, 8, 2398, 25),
woosh.Token(woosh.OP, '(', 2398, 25, 2398, 26),
woosh.Token(woosh.NAME, 'self', 2398, 26, 2398, 30),
woosh.Token(woosh.OP, ',', 2398, 30, 2398, 31),
woosh.Token(woosh.NAME, 'tarinfo', 2398, 32, 2398, 39),
woosh.Token(woosh.OP, ')', 2398, 39, 2398, 40),
woosh.Token(woosh.OP, ':', 2398, 40, 2398, 41),
woosh.Token(woosh.NEWLINE, '\r\n', 2398, 41, 2399, 0),
woosh.Token(woosh.INDENT, ' ', 2399, 0, 2399, 8),
woosh.Token(woosh.STRING, '"""Find the target member of a symlink or hardlink member in the\r\n archive.\r\n """', 2399, 8, 2401, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 2401, 11, 2402, 0),
woosh.Token(woosh.NAME, 'if', 2402, 8, 2402, 10),
woosh.Token(woosh.NAME, 'tarinfo', 2402, 11, 2402, 18),
woosh.Token(woosh.OP, '.', 2402, 18, 2402, 19),
woosh.Token(woosh.NAME, 'issym', 2402, 19, 2402, 24),
woosh.Token(woosh.OP, '(', 2402, 24, 2402, 25),
woosh.Token(woosh.OP, ')', 2402, 25, 2402, 26),
woosh.Token(woosh.OP, ':', 2402, 26, 2402, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 2402, 27, 2403, 0),
woosh.Token(woosh.COMMENT, '# Always search the entire archive.', 2403, 12, 2403, 47),
woosh.Token(woosh.INDENT, ' ', 2404, 0, 2404, 12),
woosh.Token(woosh.NAME, 'linkname', 2404, 12, 2404, 20),
woosh.Token(woosh.OP, '=', 2404, 21, 2404, 22),
woosh.Token(woosh.STRING, '"/"', 2404, 23, 2404, 26),
woosh.Token(woosh.OP, '.', 2404, 26, 2404, 27),
woosh.Token(woosh.NAME, 'join', 2404, 27, 2404, 31),
woosh.Token(woosh.OP, '(', 2404, 31, 2404, 32),
woosh.Token(woosh.NAME, 'filter', 2404, 32, 2404, 38),
woosh.Token(woosh.OP, '(', 2404, 38, 2404, 39),
woosh.Token(woosh.NAME, 'None', 2404, 39, 2404, 43),
woosh.Token(woosh.OP, ',', 2404, 43, 2404, 44),
woosh.Token(woosh.OP, '(', 2404, 45, 2404, 46),
woosh.Token(woosh.NAME, 'os', 2404, 46, 2404, 48),
woosh.Token(woosh.OP, '.', 2404, 48, 2404, 49),
woosh.Token(woosh.NAME, 'path', 2404, 49, 2404, 53),
woosh.Token(woosh.OP, '.', 2404, 53, 2404, 54),
woosh.Token(woosh.NAME, 'dirname', 2404, 54, 2404, 61),
woosh.Token(woosh.OP, '(', 2404, 61, 2404, 62),
woosh.Token(woosh.NAME, 'tarinfo', 2404, 62, 2404, 69),
woosh.Token(woosh.OP, '.', 2404, 69, 2404, 70),
woosh.Token(woosh.NAME, 'name', 2404, 70, 2404, 74),
woosh.Token(woosh.OP, ')', 2404, 74, 2404, 75),
woosh.Token(woosh.OP, ',', 2404, 75, 2404, 76),
woosh.Token(woosh.NAME, 'tarinfo', 2404, 77, 2404, 84),
woosh.Token(woosh.OP, '.', 2404, 84, 2404, 85),
woosh.Token(woosh.NAME, 'linkname', 2404, 85, 2404, 93),
woosh.Token(woosh.OP, ')', 2404, 93, 2404, 94),
woosh.Token(woosh.OP, ')', 2404, 94, 2404, 95),
woosh.Token(woosh.OP, ')', 2404, 95, 2404, 96),
woosh.Token(woosh.NEWLINE, '\r\n', 2404, 96, 2405, 0),
woosh.Token(woosh.NAME, 'limit', 2405, 12, 2405, 17),
woosh.Token(woosh.OP, '=', 2405, 18, 2405, 19),
woosh.Token(woosh.NAME, 'None', 2405, 20, 2405, 24),
woosh.Token(woosh.NEWLINE, '\r\n', 2405, 24, 2406, 0),
woosh.Token(woosh.DEDENT, ' ', 2406, 0, 2406, 8),
woosh.Token(woosh.NAME, 'else', 2406, 8, 2406, 12),
woosh.Token(woosh.OP, ':', 2406, 12, 2406, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 2406, 13, 2407, 0),
woosh.Token(woosh.COMMENT, '# Search the archive before the link, because a hard link is', 2407, 12, 2407, 72),
woosh.Token(woosh.COMMENT, '# just a reference to an already archived file.', 2408, 12, 2408, 59),
woosh.Token(woosh.INDENT, ' ', 2409, 0, 2409, 12),
woosh.Token(woosh.NAME, 'linkname', 2409, 12, 2409, 20),
woosh.Token(woosh.OP, '=', 2409, 21, 2409, 22),
woosh.Token(woosh.NAME, 'tarinfo', 2409, 23, 2409, 30),
woosh.Token(woosh.OP, '.', 2409, 30, 2409, 31),
woosh.Token(woosh.NAME, 'linkname', 2409, 31, 2409, 39),
woosh.Token(woosh.NEWLINE, '\r\n', 2409, 39, 2410, 0),
woosh.Token(woosh.NAME, 'limit', 2410, 12, 2410, 17),
woosh.Token(woosh.OP, '=', 2410, 18, 2410, 19),
woosh.Token(woosh.NAME, 'tarinfo', 2410, 20, 2410, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 2410, 27, 2411, 0),
woosh.Token(woosh.DEDENT, ' ', 2412, 0, 2412, 8),
woosh.Token(woosh.NAME, 'member', 2412, 8, 2412, 14),
woosh.Token(woosh.OP, '=', 2412, 15, 2412, 16),
woosh.Token(woosh.NAME, 'self', 2412, 17, 2412, 21),
woosh.Token(woosh.OP, '.', 2412, 21, 2412, 22),
woosh.Token(woosh.NAME, '_getmember', 2412, 22, 2412, 32),
woosh.Token(woosh.OP, '(', 2412, 32, 2412, 33),
woosh.Token(woosh.NAME, 'linkname', 2412, 33, 2412, 41),
woosh.Token(woosh.OP, ',', 2412, 41, 2412, 42),
woosh.Token(woosh.NAME, 'tarinfo', 2412, 43, 2412, 50),
woosh.Token(woosh.OP, '=', 2412, 50, 2412, 51),
woosh.Token(woosh.NAME, 'limit', 2412, 51, 2412, 56),
woosh.Token(woosh.OP, ',', 2412, 56, 2412, 57),
woosh.Token(woosh.NAME, 'normalize', 2412, 58, 2412, 67),
woosh.Token(woosh.OP, '=', 2412, 67, 2412, 68),
woosh.Token(woosh.NAME, 'True', 2412, 68, 2412, 72),
woosh.Token(woosh.OP, ')', 2412, 72, 2412, 73),
woosh.Token(woosh.NEWLINE, '\r\n', 2412, 73, 2413, 0),
woosh.Token(woosh.NAME, 'if', 2413, 8, 2413, 10),
woosh.Token(woosh.NAME, 'member', 2413, 11, 2413, 17),
woosh.Token(woosh.NAME, 'is', 2413, 18, 2413, 20),
woosh.Token(woosh.NAME, 'None', 2413, 21, 2413, 25),
woosh.Token(woosh.OP, ':', 2413, 25, 2413, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 2413, 26, 2414, 0),
woosh.Token(woosh.INDENT, ' ', 2414, 0, 2414, 12),
woosh.Token(woosh.NAME, 'raise', 2414, 12, 2414, 17),
woosh.Token(woosh.NAME, 'KeyError', 2414, 18, 2414, 26),
woosh.Token(woosh.OP, '(', 2414, 26, 2414, 27),
woosh.Token(woosh.STRING, '"linkname %r not found"', 2414, 27, 2414, 50),
woosh.Token(woosh.OP, '%', 2414, 51, 2414, 52),
woosh.Token(woosh.NAME, 'linkname', 2414, 53, 2414, 61),
woosh.Token(woosh.OP, ')', 2414, 61, 2414, 62),
woosh.Token(woosh.NEWLINE, '\r\n', 2414, 62, 2415, 0),
woosh.Token(woosh.DEDENT, ' ', 2415, 0, 2415, 8),
woosh.Token(woosh.NAME, 'return', 2415, 8, 2415, 14),
woosh.Token(woosh.NAME, 'member', 2415, 15, 2415, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 2415, 21, 2416, 0),
woosh.Token(woosh.DEDENT, ' ', 2417, 0, 2417, 4),
woosh.Token(woosh.NAME, 'def', 2417, 4, 2417, 7),
woosh.Token(woosh.NAME, '__iter__', 2417, 8, 2417, 16),
woosh.Token(woosh.OP, '(', 2417, 16, 2417, 17),
woosh.Token(woosh.NAME, 'self', 2417, 17, 2417, 21),
woosh.Token(woosh.OP, ')', 2417, 21, 2417, 22),
woosh.Token(woosh.OP, ':', 2417, 22, 2417, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 2417, 23, 2418, 0),
woosh.Token(woosh.INDENT, ' ', 2418, 0, 2418, 8),
woosh.Token(woosh.STRING, '"""Provide an iterator object.\r\n """', 2418, 8, 2419, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 2419, 11, 2420, 0),
woosh.Token(woosh.NAME, 'if', 2420, 8, 2420, 10),
woosh.Token(woosh.NAME, 'self', 2420, 11, 2420, 15),
woosh.Token(woosh.OP, '.', 2420, 15, 2420, 16),
woosh.Token(woosh.NAME, '_loaded', 2420, 16, 2420, 23),
woosh.Token(woosh.OP, ':', 2420, 23, 2420, 24),
woosh.Token(woosh.NEWLINE, '\r\n', 2420, 24, 2421, 0),
woosh.Token(woosh.INDENT, ' ', 2421, 0, 2421, 12),
woosh.Token(woosh.NAME, 'yield', 2421, 12, 2421, 17),
woosh.Token(woosh.NAME, 'from', 2421, 18, 2421, 22),
woosh.Token(woosh.NAME, 'self', 2421, 23, 2421, 27),
woosh.Token(woosh.OP, '.', 2421, 27, 2421, 28),
woosh.Token(woosh.NAME, 'members', 2421, 28, 2421, 35),
woosh.Token(woosh.NEWLINE, '\r\n', 2421, 35, 2422, 0),
woosh.Token(woosh.NAME, 'return', 2422, 12, 2422, 18),
woosh.Token(woosh.NEWLINE, '\r\n', 2422, 18, 2423, 0),
woosh.Token(woosh.COMMENT, "# Yield items using TarFile's next() method.", 2424, 8, 2424, 52),
woosh.Token(woosh.COMMENT, '# When all members have been read, set TarFile as _loaded.', 2425, 8, 2425, 66),
woosh.Token(woosh.DEDENT, ' ', 2426, 0, 2426, 8),
woosh.Token(woosh.NAME, 'index', 2426, 8, 2426, 13),
woosh.Token(woosh.OP, '=', 2426, 14, 2426, 15),
woosh.Token(woosh.NUMBER, '0', 2426, 16, 2426, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 2426, 17, 2427, 0),
woosh.Token(woosh.COMMENT, '# Fix for SF #1100429: Under rare circumstances it can', 2427, 8, 2427, 62),
woosh.Token(woosh.COMMENT, '# happen that getmembers() is called during iteration,', 2428, 8, 2428, 62),
woosh.Token(woosh.COMMENT, '# which will have already exhausted the next() method.', 2429, 8, 2429, 62),
woosh.Token(woosh.NAME, 'if', 2430, 8, 2430, 10),
woosh.Token(woosh.NAME, 'self', 2430, 11, 2430, 15),
woosh.Token(woosh.OP, '.', 2430, 15, 2430, 16),
woosh.Token(woosh.NAME, 'firstmember', 2430, 16, 2430, 27),
woosh.Token(woosh.NAME, 'is', 2430, 28, 2430, 30),
woosh.Token(woosh.NAME, 'not', 2430, 31, 2430, 34),
woosh.Token(woosh.NAME, 'None', 2430, 35, 2430, 39),
woosh.Token(woosh.OP, ':', 2430, 39, 2430, 40),
woosh.Token(woosh.NEWLINE, '\r\n', 2430, 40, 2431, 0),
woosh.Token(woosh.INDENT, ' ', 2431, 0, 2431, 12),
woosh.Token(woosh.NAME, 'tarinfo', 2431, 12, 2431, 19),
woosh.Token(woosh.OP, '=', 2431, 20, 2431, 21),
woosh.Token(woosh.NAME, 'self', 2431, 22, 2431, 26),
woosh.Token(woosh.OP, '.', 2431, 26, 2431, 27),
woosh.Token(woosh.NAME, 'next', 2431, 27, 2431, 31),
woosh.Token(woosh.OP, '(', 2431, 31, 2431, 32),
woosh.Token(woosh.OP, ')', 2431, 32, 2431, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 2431, 33, 2432, 0),
woosh.Token(woosh.NAME, 'index', 2432, 12, 2432, 17),
woosh.Token(woosh.OP, '+=', 2432, 18, 2432, 20),
woosh.Token(woosh.NUMBER, '1', 2432, 21, 2432, 22),
woosh.Token(woosh.NEWLINE, '\r\n', 2432, 22, 2433, 0),
woosh.Token(woosh.NAME, 'yield', 2433, 12, 2433, 17),
woosh.Token(woosh.NAME, 'tarinfo', 2433, 18, 2433, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 2433, 25, 2434, 0),
woosh.Token(woosh.DEDENT, ' ', 2435, 0, 2435, 8),
woosh.Token(woosh.NAME, 'while', 2435, 8, 2435, 13),
woosh.Token(woosh.NAME, 'True', 2435, 14, 2435, 18),
woosh.Token(woosh.OP, ':', 2435, 18, 2435, 19),
woosh.Token(woosh.NEWLINE, '\r\n', 2435, 19, 2436, 0),
woosh.Token(woosh.INDENT, ' ', 2436, 0, 2436, 12),
woosh.Token(woosh.NAME, 'if', 2436, 12, 2436, 14),
woosh.Token(woosh.NAME, 'index', 2436, 15, 2436, 20),
woosh.Token(woosh.OP, '<', 2436, 21, 2436, 22),
woosh.Token(woosh.NAME, 'len', 2436, 23, 2436, 26),
woosh.Token(woosh.OP, '(', 2436, 26, 2436, 27),
woosh.Token(woosh.NAME, 'self', 2436, 27, 2436, 31),
woosh.Token(woosh.OP, '.', 2436, 31, 2436, 32),
woosh.Token(woosh.NAME, 'members', 2436, 32, 2436, 39),
woosh.Token(woosh.OP, ')', 2436, 39, 2436, 40),
woosh.Token(woosh.OP, ':', 2436, 40, 2436, 41),
woosh.Token(woosh.NEWLINE, '\r\n', 2436, 41, 2437, 0),
woosh.Token(woosh.INDENT, ' ', 2437, 0, 2437, 16),
woosh.Token(woosh.NAME, 'tarinfo', 2437, 16, 2437, 23),
woosh.Token(woosh.OP, '=', 2437, 24, 2437, 25),
woosh.Token(woosh.NAME, 'self', 2437, 26, 2437, 30),
woosh.Token(woosh.OP, '.', 2437, 30, 2437, 31),
woosh.Token(woosh.NAME, 'members', 2437, 31, 2437, 38),
woosh.Token(woosh.OP, '[', 2437, 38, 2437, 39),
woosh.Token(woosh.NAME, 'index', 2437, 39, 2437, 44),
woosh.Token(woosh.OP, ']', 2437, 44, 2437, 45),
woosh.Token(woosh.NEWLINE, '\r\n', 2437, 45, 2438, 0),
woosh.Token(woosh.DEDENT, ' ', 2438, 0, 2438, 12),
woosh.Token(woosh.NAME, 'elif', 2438, 12, 2438, 16),
woosh.Token(woosh.NAME, 'not', 2438, 17, 2438, 20),
woosh.Token(woosh.NAME, 'self', 2438, 21, 2438, 25),
woosh.Token(woosh.OP, '.', 2438, 25, 2438, 26),
woosh.Token(woosh.NAME, '_loaded', 2438, 26, 2438, 33),
woosh.Token(woosh.OP, ':', 2438, 33, 2438, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 2438, 34, 2439, 0),
woosh.Token(woosh.INDENT, ' ', 2439, 0, 2439, 16),
woosh.Token(woosh.NAME, 'tarinfo', 2439, 16, 2439, 23),
woosh.Token(woosh.OP, '=', 2439, 24, 2439, 25),
woosh.Token(woosh.NAME, 'self', 2439, 26, 2439, 30),
woosh.Token(woosh.OP, '.', 2439, 30, 2439, 31),
woosh.Token(woosh.NAME, 'next', 2439, 31, 2439, 35),
woosh.Token(woosh.OP, '(', 2439, 35, 2439, 36),
woosh.Token(woosh.OP, ')', 2439, 36, 2439, 37),
woosh.Token(woosh.NEWLINE, '\r\n', 2439, 37, 2440, 0),
woosh.Token(woosh.NAME, 'if', 2440, 16, 2440, 18),
woosh.Token(woosh.NAME, 'not', 2440, 19, 2440, 22),
woosh.Token(woosh.NAME, 'tarinfo', 2440, 23, 2440, 30),
woosh.Token(woosh.OP, ':', 2440, 30, 2440, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 2440, 31, 2441, 0),
woosh.Token(woosh.INDENT, ' ', 2441, 0, 2441, 20),
woosh.Token(woosh.NAME, 'self', 2441, 20, 2441, 24),
woosh.Token(woosh.OP, '.', 2441, 24, 2441, 25),
woosh.Token(woosh.NAME, '_loaded', 2441, 25, 2441, 32),
woosh.Token(woosh.OP, '=', 2441, 33, 2441, 34),
woosh.Token(woosh.NAME, 'True', 2441, 35, 2441, 39),
woosh.Token(woosh.NEWLINE, '\r\n', 2441, 39, 2442, 0),
woosh.Token(woosh.NAME, 'return', 2442, 20, 2442, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 2442, 26, 2443, 0),
woosh.Token(woosh.DEDENT, ' ', 2443, 0, 2443, 12),
woosh.Token(woosh.DEDENT, '', 2443, 12, 2443, 12),
woosh.Token(woosh.NAME, 'else', 2443, 12, 2443, 16),
woosh.Token(woosh.OP, ':', 2443, 16, 2443, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 2443, 17, 2444, 0),
woosh.Token(woosh.INDENT, ' ', 2444, 0, 2444, 16),
woosh.Token(woosh.NAME, 'return', 2444, 16, 2444, 22),
woosh.Token(woosh.NEWLINE, '\r\n', 2444, 22, 2445, 0),
woosh.Token(woosh.DEDENT, ' ', 2445, 0, 2445, 12),
woosh.Token(woosh.NAME, 'index', 2445, 12, 2445, 17),
woosh.Token(woosh.OP, '+=', 2445, 18, 2445, 20),
woosh.Token(woosh.NUMBER, '1', 2445, 21, 2445, 22),
woosh.Token(woosh.NEWLINE, '\r\n', 2445, 22, 2446, 0),
woosh.Token(woosh.NAME, 'yield', 2446, 12, 2446, 17),
woosh.Token(woosh.NAME, 'tarinfo', 2446, 18, 2446, 25),
woosh.Token(woosh.NEWLINE, '\r\n', 2446, 25, 2447, 0),
woosh.Token(woosh.DEDENT, ' ', 2448, 0, 2448, 4),
woosh.Token(woosh.DEDENT, '', 2448, 4, 2448, 4),
woosh.Token(woosh.NAME, 'def', 2448, 4, 2448, 7),
woosh.Token(woosh.NAME, '_dbg', 2448, 8, 2448, 12),
woosh.Token(woosh.OP, '(', 2448, 12, 2448, 13),
woosh.Token(woosh.NAME, 'self', 2448, 13, 2448, 17),
woosh.Token(woosh.OP, ',', 2448, 17, 2448, 18),
woosh.Token(woosh.NAME, 'level', 2448, 19, 2448, 24),
woosh.Token(woosh.OP, ',', 2448, 24, 2448, 25),
woosh.Token(woosh.NAME, 'msg', 2448, 26, 2448, 29),
woosh.Token(woosh.OP, ')', 2448, 29, 2448, 30),
woosh.Token(woosh.OP, ':', 2448, 30, 2448, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 2448, 31, 2449, 0),
woosh.Token(woosh.INDENT, ' ', 2449, 0, 2449, 8),
woosh.Token(woosh.STRING, '"""Write debugging output to sys.stderr.\r\n """', 2449, 8, 2450, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 2450, 11, 2451, 0),
woosh.Token(woosh.NAME, 'if', 2451, 8, 2451, 10),
woosh.Token(woosh.NAME, 'level', 2451, 11, 2451, 16),
woosh.Token(woosh.OP, '<=', 2451, 17, 2451, 19),
woosh.Token(woosh.NAME, 'self', 2451, 20, 2451, 24),
woosh.Token(woosh.OP, '.', 2451, 24, 2451, 25),
woosh.Token(woosh.NAME, 'debug', 2451, 25, 2451, 30),
woosh.Token(woosh.OP, ':', 2451, 30, 2451, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 2451, 31, 2452, 0),
woosh.Token(woosh.INDENT, ' ', 2452, 0, 2452, 12),
woosh.Token(woosh.NAME, 'print', 2452, 12, 2452, 17),
woosh.Token(woosh.OP, '(', 2452, 17, 2452, 18),
woosh.Token(woosh.NAME, 'msg', 2452, 18, 2452, 21),
woosh.Token(woosh.OP, ',', 2452, 21, 2452, 22),
woosh.Token(woosh.NAME, 'file', 2452, 23, 2452, 27),
woosh.Token(woosh.OP, '=', 2452, 27, 2452, 28),
woosh.Token(woosh.NAME, 'sys', 2452, 28, 2452, 31),
woosh.Token(woosh.OP, '.', 2452, 31, 2452, 32),
woosh.Token(woosh.NAME, 'stderr', 2452, 32, 2452, 38),
woosh.Token(woosh.OP, ')', 2452, 38, 2452, 39),
woosh.Token(woosh.NEWLINE, '\r\n', 2452, 39, 2453, 0),
woosh.Token(woosh.DEDENT, ' ', 2454, 0, 2454, 4),
woosh.Token(woosh.DEDENT, '', 2454, 4, 2454, 4),
woosh.Token(woosh.NAME, 'def', 2454, 4, 2454, 7),
woosh.Token(woosh.NAME, '__enter__', 2454, 8, 2454, 17),
woosh.Token(woosh.OP, '(', 2454, 17, 2454, 18),
woosh.Token(woosh.NAME, 'self', 2454, 18, 2454, 22),
woosh.Token(woosh.OP, ')', 2454, 22, 2454, 23),
woosh.Token(woosh.OP, ':', 2454, 23, 2454, 24),
woosh.Token(woosh.NEWLINE, '\r\n', 2454, 24, 2455, 0),
woosh.Token(woosh.INDENT, ' ', 2455, 0, 2455, 8),
woosh.Token(woosh.NAME, 'self', 2455, 8, 2455, 12),
woosh.Token(woosh.OP, '.', 2455, 12, 2455, 13),
woosh.Token(woosh.NAME, '_check', 2455, 13, 2455, 19),
woosh.Token(woosh.OP, '(', 2455, 19, 2455, 20),
woosh.Token(woosh.OP, ')', 2455, 20, 2455, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 2455, 21, 2456, 0),
woosh.Token(woosh.NAME, 'return', 2456, 8, 2456, 14),
woosh.Token(woosh.NAME, 'self', 2456, 15, 2456, 19),
woosh.Token(woosh.NEWLINE, '\r\n', 2456, 19, 2457, 0),
woosh.Token(woosh.DEDENT, ' ', 2458, 0, 2458, 4),
woosh.Token(woosh.NAME, 'def', 2458, 4, 2458, 7),
woosh.Token(woosh.NAME, '__exit__', 2458, 8, 2458, 16),
woosh.Token(woosh.OP, '(', 2458, 16, 2458, 17),
woosh.Token(woosh.NAME, 'self', 2458, 17, 2458, 21),
woosh.Token(woosh.OP, ',', 2458, 21, 2458, 22),
woosh.Token(woosh.NAME, 'type', 2458, 23, 2458, 27),
woosh.Token(woosh.OP, ',', 2458, 27, 2458, 28),
woosh.Token(woosh.NAME, 'value', 2458, 29, 2458, 34),
woosh.Token(woosh.OP, ',', 2458, 34, 2458, 35),
woosh.Token(woosh.NAME, 'traceback', 2458, 36, 2458, 45),
woosh.Token(woosh.OP, ')', 2458, 45, 2458, 46),
woosh.Token(woosh.OP, ':', 2458, 46, 2458, 47),
woosh.Token(woosh.NEWLINE, '\r\n', 2458, 47, 2459, 0),
woosh.Token(woosh.INDENT, ' ', 2459, 0, 2459, 8),
woosh.Token(woosh.NAME, 'if', 2459, 8, 2459, 10),
woosh.Token(woosh.NAME, 'type', 2459, 11, 2459, 15),
woosh.Token(woosh.NAME, 'is', 2459, 16, 2459, 18),
woosh.Token(woosh.NAME, 'None', 2459, 19, 2459, 23),
woosh.Token(woosh.OP, ':', 2459, 23, 2459, 24),
woosh.Token(woosh.NEWLINE, '\r\n', 2459, 24, 2460, 0),
woosh.Token(woosh.INDENT, ' ', 2460, 0, 2460, 12),
woosh.Token(woosh.NAME, 'self', 2460, 12, 2460, 16),
woosh.Token(woosh.OP, '.', 2460, 16, 2460, 17),
woosh.Token(woosh.NAME, 'close', 2460, 17, 2460, 22),
woosh.Token(woosh.OP, '(', 2460, 22, 2460, 23),
woosh.Token(woosh.OP, ')', 2460, 23, 2460, 24),
woosh.Token(woosh.NEWLINE, '\r\n', 2460, 24, 2461, 0),
woosh.Token(woosh.DEDENT, ' ', 2461, 0, 2461, 8),
woosh.Token(woosh.NAME, 'else', 2461, 8, 2461, 12),
woosh.Token(woosh.OP, ':', 2461, 12, 2461, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 2461, 13, 2462, 0),
woosh.Token(woosh.COMMENT, '# An exception occurred. We must not call close() because', 2462, 12, 2462, 69),
woosh.Token(woosh.COMMENT, '# it would try to write end-of-archive blocks and padding.', 2463, 12, 2463, 70),
woosh.Token(woosh.INDENT, ' ', 2464, 0, 2464, 12),
woosh.Token(woosh.NAME, 'if', 2464, 12, 2464, 14),
woosh.Token(woosh.NAME, 'not', 2464, 15, 2464, 18),
woosh.Token(woosh.NAME, 'self', 2464, 19, 2464, 23),
woosh.Token(woosh.OP, '.', 2464, 23, 2464, 24),
woosh.Token(woosh.NAME, '_extfileobj', 2464, 24, 2464, 35),
woosh.Token(woosh.OP, ':', 2464, 35, 2464, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 2464, 36, 2465, 0),
woosh.Token(woosh.INDENT, ' ', 2465, 0, 2465, 16),
woosh.Token(woosh.NAME, 'self', 2465, 16, 2465, 20),
woosh.Token(woosh.OP, '.', 2465, 20, 2465, 21),
woosh.Token(woosh.NAME, 'fileobj', 2465, 21, 2465, 28),
woosh.Token(woosh.OP, '.', 2465, 28, 2465, 29),
woosh.Token(woosh.NAME, 'close', 2465, 29, 2465, 34),
woosh.Token(woosh.OP, '(', 2465, 34, 2465, 35),
woosh.Token(woosh.OP, ')', 2465, 35, 2465, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 2465, 36, 2466, 0),
woosh.Token(woosh.DEDENT, ' ', 2466, 0, 2466, 12),
woosh.Token(woosh.NAME, 'self', 2466, 12, 2466, 16),
woosh.Token(woosh.OP, '.', 2466, 16, 2466, 17),
woosh.Token(woosh.NAME, 'closed', 2466, 17, 2466, 23),
woosh.Token(woosh.OP, '=', 2466, 24, 2466, 25),
woosh.Token(woosh.NAME, 'True', 2466, 26, 2466, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 2466, 30, 2467, 0),
woosh.Token(woosh.COMMENT, '#--------------------', 2468, 0, 2468, 21),
woosh.Token(woosh.COMMENT, '# exported functions', 2469, 0, 2469, 20),
woosh.Token(woosh.COMMENT, '#--------------------', 2470, 0, 2470, 21),
woosh.Token(woosh.DEDENT, '', 2471, 0, 2471, 0),
woosh.Token(woosh.DEDENT, '', 2471, 0, 2471, 0),
woosh.Token(woosh.DEDENT, '', 2471, 0, 2471, 0),
woosh.Token(woosh.NAME, 'def', 2471, 0, 2471, 3),
woosh.Token(woosh.NAME, 'is_tarfile', 2471, 4, 2471, 14),
woosh.Token(woosh.OP, '(', 2471, 14, 2471, 15),
woosh.Token(woosh.NAME, 'name', 2471, 15, 2471, 19),
woosh.Token(woosh.OP, ')', 2471, 19, 2471, 20),
woosh.Token(woosh.OP, ':', 2471, 20, 2471, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 2471, 21, 2472, 0),
woosh.Token(woosh.INDENT, ' ', 2472, 0, 2472, 4),
woosh.Token(woosh.STRING, '"""Return True if name points to a tar archive that we\r\n are able to handle, else return False.\r\n\r\n \'name\' should be a string, file, or file-like object.\r\n """', 2472, 4, 2476, 7),
woosh.Token(woosh.NEWLINE, '\r\n', 2476, 7, 2477, 0),
woosh.Token(woosh.NAME, 'try', 2477, 4, 2477, 7),
woosh.Token(woosh.OP, ':', 2477, 7, 2477, 8),
woosh.Token(woosh.NEWLINE, '\r\n', 2477, 8, 2478, 0),
woosh.Token(woosh.INDENT, ' ', 2478, 0, 2478, 8),
woosh.Token(woosh.NAME, 'if', 2478, 8, 2478, 10),
woosh.Token(woosh.NAME, 'hasattr', 2478, 11, 2478, 18),
woosh.Token(woosh.OP, '(', 2478, 18, 2478, 19),
woosh.Token(woosh.NAME, 'name', 2478, 19, 2478, 23),
woosh.Token(woosh.OP, ',', 2478, 23, 2478, 24),
woosh.Token(woosh.STRING, '"read"', 2478, 25, 2478, 31),
woosh.Token(woosh.OP, ')', 2478, 31, 2478, 32),
woosh.Token(woosh.OP, ':', 2478, 32, 2478, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 2478, 33, 2479, 0),
woosh.Token(woosh.INDENT, ' ', 2479, 0, 2479, 12),
woosh.Token(woosh.NAME, 't', 2479, 12, 2479, 13),
woosh.Token(woosh.OP, '=', 2479, 14, 2479, 15),
woosh.Token(woosh.NAME, 'open', 2479, 16, 2479, 20),
woosh.Token(woosh.OP, '(', 2479, 20, 2479, 21),
woosh.Token(woosh.NAME, 'fileobj', 2479, 21, 2479, 28),
woosh.Token(woosh.OP, '=', 2479, 28, 2479, 29),
woosh.Token(woosh.NAME, 'name', 2479, 29, 2479, 33),
woosh.Token(woosh.OP, ')', 2479, 33, 2479, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 2479, 34, 2480, 0),
woosh.Token(woosh.DEDENT, ' ', 2480, 0, 2480, 8),
woosh.Token(woosh.NAME, 'else', 2480, 8, 2480, 12),
woosh.Token(woosh.OP, ':', 2480, 12, 2480, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 2480, 13, 2481, 0),
woosh.Token(woosh.INDENT, ' ', 2481, 0, 2481, 12),
woosh.Token(woosh.NAME, 't', 2481, 12, 2481, 13),
woosh.Token(woosh.OP, '=', 2481, 14, 2481, 15),
woosh.Token(woosh.NAME, 'open', 2481, 16, 2481, 20),
woosh.Token(woosh.OP, '(', 2481, 20, 2481, 21),
woosh.Token(woosh.NAME, 'name', 2481, 21, 2481, 25),
woosh.Token(woosh.OP, ')', 2481, 25, 2481, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 2481, 26, 2482, 0),
woosh.Token(woosh.DEDENT, ' ', 2482, 0, 2482, 8),
woosh.Token(woosh.NAME, 't', 2482, 8, 2482, 9),
woosh.Token(woosh.OP, '.', 2482, 9, 2482, 10),
woosh.Token(woosh.NAME, 'close', 2482, 10, 2482, 15),
woosh.Token(woosh.OP, '(', 2482, 15, 2482, 16),
woosh.Token(woosh.OP, ')', 2482, 16, 2482, 17),
woosh.Token(woosh.NEWLINE, '\r\n', 2482, 17, 2483, 0),
woosh.Token(woosh.NAME, 'return', 2483, 8, 2483, 14),
woosh.Token(woosh.NAME, 'True', 2483, 15, 2483, 19),
woosh.Token(woosh.NEWLINE, '\r\n', 2483, 19, 2484, 0),
woosh.Token(woosh.DEDENT, ' ', 2484, 0, 2484, 4),
woosh.Token(woosh.NAME, 'except', 2484, 4, 2484, 10),
woosh.Token(woosh.NAME, 'TarError', 2484, 11, 2484, 19),
woosh.Token(woosh.OP, ':', 2484, 19, 2484, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 2484, 20, 2485, 0),
woosh.Token(woosh.INDENT, ' ', 2485, 0, 2485, 8),
woosh.Token(woosh.NAME, 'return', 2485, 8, 2485, 14),
woosh.Token(woosh.NAME, 'False', 2485, 15, 2485, 20),
woosh.Token(woosh.NEWLINE, '\r\n', 2485, 20, 2486, 0),
woosh.Token(woosh.DEDENT, '', 2487, 0, 2487, 0),
woosh.Token(woosh.DEDENT, '', 2487, 0, 2487, 0),
woosh.Token(woosh.NAME, 'open', 2487, 0, 2487, 4),
woosh.Token(woosh.OP, '=', 2487, 5, 2487, 6),
woosh.Token(woosh.NAME, 'TarFile', 2487, 7, 2487, 14),
woosh.Token(woosh.OP, '.', 2487, 14, 2487, 15),
woosh.Token(woosh.NAME, 'open', 2487, 15, 2487, 19),
woosh.Token(woosh.NEWLINE, '\r\n', 2487, 19, 2488, 0),
woosh.Token(woosh.NAME, 'def', 2490, 0, 2490, 3),
woosh.Token(woosh.NAME, 'main', 2490, 4, 2490, 8),
woosh.Token(woosh.OP, '(', 2490, 8, 2490, 9),
woosh.Token(woosh.OP, ')', 2490, 9, 2490, 10),
woosh.Token(woosh.OP, ':', 2490, 10, 2490, 11),
woosh.Token(woosh.NEWLINE, '\r\n', 2490, 11, 2491, 0),
woosh.Token(woosh.INDENT, ' ', 2491, 0, 2491, 4),
woosh.Token(woosh.NAME, 'import', 2491, 4, 2491, 10),
woosh.Token(woosh.NAME, 'argparse', 2491, 11, 2491, 19),
woosh.Token(woosh.NEWLINE, '\r\n', 2491, 19, 2492, 0),
woosh.Token(woosh.NAME, 'description', 2493, 4, 2493, 15),
woosh.Token(woosh.OP, '=', 2493, 16, 2493, 17),
woosh.Token(woosh.STRING, "'A simple command-line interface for tarfile module.'", 2493, 18, 2493, 71),
woosh.Token(woosh.NEWLINE, '\r\n', 2493, 71, 2494, 0),
woosh.Token(woosh.NAME, 'parser', 2494, 4, 2494, 10),
woosh.Token(woosh.OP, '=', 2494, 11, 2494, 12),
woosh.Token(woosh.NAME, 'argparse', 2494, 13, 2494, 21),
woosh.Token(woosh.OP, '.', 2494, 21, 2494, 22),
woosh.Token(woosh.NAME, 'ArgumentParser', 2494, 22, 2494, 36),
woosh.Token(woosh.OP, '(', 2494, 36, 2494, 37),
woosh.Token(woosh.NAME, 'description', 2494, 37, 2494, 48),
woosh.Token(woosh.OP, '=', 2494, 48, 2494, 49),
woosh.Token(woosh.NAME, 'description', 2494, 49, 2494, 60),
woosh.Token(woosh.OP, ')', 2494, 60, 2494, 61),
woosh.Token(woosh.NEWLINE, '\r\n', 2494, 61, 2495, 0),
woosh.Token(woosh.NAME, 'parser', 2495, 4, 2495, 10),
woosh.Token(woosh.OP, '.', 2495, 10, 2495, 11),
woosh.Token(woosh.NAME, 'add_argument', 2495, 11, 2495, 23),
woosh.Token(woosh.OP, '(', 2495, 23, 2495, 24),
woosh.Token(woosh.STRING, "'-v'", 2495, 24, 2495, 28),
woosh.Token(woosh.OP, ',', 2495, 28, 2495, 29),
woosh.Token(woosh.STRING, "'--verbose'", 2495, 30, 2495, 41),
woosh.Token(woosh.OP, ',', 2495, 41, 2495, 42),
woosh.Token(woosh.NAME, 'action', 2495, 43, 2495, 49),
woosh.Token(woosh.OP, '=', 2495, 49, 2495, 50),
woosh.Token(woosh.STRING, "'store_true'", 2495, 50, 2495, 62),
woosh.Token(woosh.OP, ',', 2495, 62, 2495, 63),
woosh.Token(woosh.NAME, 'default', 2495, 64, 2495, 71),
woosh.Token(woosh.OP, '=', 2495, 71, 2495, 72),
woosh.Token(woosh.NAME, 'False', 2495, 72, 2495, 77),
woosh.Token(woosh.OP, ',', 2495, 77, 2495, 78),
woosh.Token(woosh.NAME, 'help', 2496, 24, 2496, 28),
woosh.Token(woosh.OP, '=', 2496, 28, 2496, 29),
woosh.Token(woosh.STRING, "'Verbose output'", 2496, 29, 2496, 45),
woosh.Token(woosh.OP, ')', 2496, 45, 2496, 46),
woosh.Token(woosh.NEWLINE, '\r\n', 2496, 46, 2497, 0),
woosh.Token(woosh.NAME, 'group', 2497, 4, 2497, 9),
woosh.Token(woosh.OP, '=', 2497, 10, 2497, 11),
woosh.Token(woosh.NAME, 'parser', 2497, 12, 2497, 18),
woosh.Token(woosh.OP, '.', 2497, 18, 2497, 19),
woosh.Token(woosh.NAME, 'add_mutually_exclusive_group', 2497, 19, 2497, 47),
woosh.Token(woosh.OP, '(', 2497, 47, 2497, 48),
woosh.Token(woosh.NAME, 'required', 2497, 48, 2497, 56),
woosh.Token(woosh.OP, '=', 2497, 56, 2497, 57),
woosh.Token(woosh.NAME, 'True', 2497, 57, 2497, 61),
woosh.Token(woosh.OP, ')', 2497, 61, 2497, 62),
woosh.Token(woosh.NEWLINE, '\r\n', 2497, 62, 2498, 0),
woosh.Token(woosh.NAME, 'group', 2498, 4, 2498, 9),
woosh.Token(woosh.OP, '.', 2498, 9, 2498, 10),
woosh.Token(woosh.NAME, 'add_argument', 2498, 10, 2498, 22),
woosh.Token(woosh.OP, '(', 2498, 22, 2498, 23),
woosh.Token(woosh.STRING, "'-l'", 2498, 23, 2498, 27),
woosh.Token(woosh.OP, ',', 2498, 27, 2498, 28),
woosh.Token(woosh.STRING, "'--list'", 2498, 29, 2498, 37),
woosh.Token(woosh.OP, ',', 2498, 37, 2498, 38),
woosh.Token(woosh.NAME, 'metavar', 2498, 39, 2498, 46),
woosh.Token(woosh.OP, '=', 2498, 46, 2498, 47),
woosh.Token(woosh.STRING, "'<tarfile>'", 2498, 47, 2498, 58),
woosh.Token(woosh.OP, ',', 2498, 58, 2498, 59),
woosh.Token(woosh.NAME, 'help', 2499, 23, 2499, 27),
woosh.Token(woosh.OP, '=', 2499, 27, 2499, 28),
woosh.Token(woosh.STRING, "'Show listing of a tarfile'", 2499, 28, 2499, 55),
woosh.Token(woosh.OP, ')', 2499, 55, 2499, 56),
woosh.Token(woosh.NEWLINE, '\r\n', 2499, 56, 2500, 0),
woosh.Token(woosh.NAME, 'group', 2500, 4, 2500, 9),
woosh.Token(woosh.OP, '.', 2500, 9, 2500, 10),
woosh.Token(woosh.NAME, 'add_argument', 2500, 10, 2500, 22),
woosh.Token(woosh.OP, '(', 2500, 22, 2500, 23),
woosh.Token(woosh.STRING, "'-e'", 2500, 23, 2500, 27),
woosh.Token(woosh.OP, ',', 2500, 27, 2500, 28),
woosh.Token(woosh.STRING, "'--extract'", 2500, 29, 2500, 40),
woosh.Token(woosh.OP, ',', 2500, 40, 2500, 41),
woosh.Token(woosh.NAME, 'nargs', 2500, 42, 2500, 47),
woosh.Token(woosh.OP, '=', 2500, 47, 2500, 48),
woosh.Token(woosh.STRING, "'+'", 2500, 48, 2500, 51),
woosh.Token(woosh.OP, ',', 2500, 51, 2500, 52),
woosh.Token(woosh.NAME, 'metavar', 2501, 23, 2501, 30),
woosh.Token(woosh.OP, '=', 2501, 30, 2501, 31),
woosh.Token(woosh.OP, '(', 2501, 31, 2501, 32),
woosh.Token(woosh.STRING, "'<tarfile>'", 2501, 32, 2501, 43),
woosh.Token(woosh.OP, ',', 2501, 43, 2501, 44),
woosh.Token(woosh.STRING, "'<output_dir>'", 2501, 45, 2501, 59),
woosh.Token(woosh.OP, ')', 2501, 59, 2501, 60),
woosh.Token(woosh.OP, ',', 2501, 60, 2501, 61),
woosh.Token(woosh.NAME, 'help', 2502, 23, 2502, 27),
woosh.Token(woosh.OP, '=', 2502, 27, 2502, 28),
woosh.Token(woosh.STRING, "'Extract tarfile into target dir'", 2502, 28, 2502, 61),
woosh.Token(woosh.OP, ')', 2502, 61, 2502, 62),
woosh.Token(woosh.NEWLINE, '\r\n', 2502, 62, 2503, 0),
woosh.Token(woosh.NAME, 'group', 2503, 4, 2503, 9),
woosh.Token(woosh.OP, '.', 2503, 9, 2503, 10),
woosh.Token(woosh.NAME, 'add_argument', 2503, 10, 2503, 22),
woosh.Token(woosh.OP, '(', 2503, 22, 2503, 23),
woosh.Token(woosh.STRING, "'-c'", 2503, 23, 2503, 27),
woosh.Token(woosh.OP, ',', 2503, 27, 2503, 28),
woosh.Token(woosh.STRING, "'--create'", 2503, 29, 2503, 39),
woosh.Token(woosh.OP, ',', 2503, 39, 2503, 40),
woosh.Token(woosh.NAME, 'nargs', 2503, 41, 2503, 46),
woosh.Token(woosh.OP, '=', 2503, 46, 2503, 47),
woosh.Token(woosh.STRING, "'+'", 2503, 47, 2503, 50),
woosh.Token(woosh.OP, ',', 2503, 50, 2503, 51),
woosh.Token(woosh.NAME, 'metavar', 2504, 23, 2504, 30),
woosh.Token(woosh.OP, '=', 2504, 30, 2504, 31),
woosh.Token(woosh.OP, '(', 2504, 31, 2504, 32),
woosh.Token(woosh.STRING, "'<name>'", 2504, 32, 2504, 40),
woosh.Token(woosh.OP, ',', 2504, 40, 2504, 41),
woosh.Token(woosh.STRING, "'<file>'", 2504, 42, 2504, 50),
woosh.Token(woosh.OP, ')', 2504, 50, 2504, 51),
woosh.Token(woosh.OP, ',', 2504, 51, 2504, 52),
woosh.Token(woosh.NAME, 'help', 2505, 23, 2505, 27),
woosh.Token(woosh.OP, '=', 2505, 27, 2505, 28),
woosh.Token(woosh.STRING, "'Create tarfile from sources'", 2505, 28, 2505, 57),
woosh.Token(woosh.OP, ')', 2505, 57, 2505, 58),
woosh.Token(woosh.NEWLINE, '\r\n', 2505, 58, 2506, 0),
woosh.Token(woosh.NAME, 'group', 2506, 4, 2506, 9),
woosh.Token(woosh.OP, '.', 2506, 9, 2506, 10),
woosh.Token(woosh.NAME, 'add_argument', 2506, 10, 2506, 22),
woosh.Token(woosh.OP, '(', 2506, 22, 2506, 23),
woosh.Token(woosh.STRING, "'-t'", 2506, 23, 2506, 27),
woosh.Token(woosh.OP, ',', 2506, 27, 2506, 28),
woosh.Token(woosh.STRING, "'--test'", 2506, 29, 2506, 37),
woosh.Token(woosh.OP, ',', 2506, 37, 2506, 38),
woosh.Token(woosh.NAME, 'metavar', 2506, 39, 2506, 46),
woosh.Token(woosh.OP, '=', 2506, 46, 2506, 47),
woosh.Token(woosh.STRING, "'<tarfile>'", 2506, 47, 2506, 58),
woosh.Token(woosh.OP, ',', 2506, 58, 2506, 59),
woosh.Token(woosh.NAME, 'help', 2507, 23, 2507, 27),
woosh.Token(woosh.OP, '=', 2507, 27, 2507, 28),
woosh.Token(woosh.STRING, "'Test if a tarfile is valid'", 2507, 28, 2507, 56),
woosh.Token(woosh.OP, ')', 2507, 56, 2507, 57),
woosh.Token(woosh.NEWLINE, '\r\n', 2507, 57, 2508, 0),
woosh.Token(woosh.NAME, 'args', 2508, 4, 2508, 8),
woosh.Token(woosh.OP, '=', 2508, 9, 2508, 10),
woosh.Token(woosh.NAME, 'parser', 2508, 11, 2508, 17),
woosh.Token(woosh.OP, '.', 2508, 17, 2508, 18),
woosh.Token(woosh.NAME, 'parse_args', 2508, 18, 2508, 28),
woosh.Token(woosh.OP, '(', 2508, 28, 2508, 29),
woosh.Token(woosh.OP, ')', 2508, 29, 2508, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 2508, 30, 2509, 0),
woosh.Token(woosh.NAME, 'if', 2510, 4, 2510, 6),
woosh.Token(woosh.NAME, 'args', 2510, 7, 2510, 11),
woosh.Token(woosh.OP, '.', 2510, 11, 2510, 12),
woosh.Token(woosh.NAME, 'test', 2510, 12, 2510, 16),
woosh.Token(woosh.NAME, 'is', 2510, 17, 2510, 19),
woosh.Token(woosh.NAME, 'not', 2510, 20, 2510, 23),
woosh.Token(woosh.NAME, 'None', 2510, 24, 2510, 28),
woosh.Token(woosh.OP, ':', 2510, 28, 2510, 29),
woosh.Token(woosh.NEWLINE, '\r\n', 2510, 29, 2511, 0),
woosh.Token(woosh.INDENT, ' ', 2511, 0, 2511, 8),
woosh.Token(woosh.NAME, 'src', 2511, 8, 2511, 11),
woosh.Token(woosh.OP, '=', 2511, 12, 2511, 13),
woosh.Token(woosh.NAME, 'args', 2511, 14, 2511, 18),
woosh.Token(woosh.OP, '.', 2511, 18, 2511, 19),
woosh.Token(woosh.NAME, 'test', 2511, 19, 2511, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 2511, 23, 2512, 0),
woosh.Token(woosh.NAME, 'if', 2512, 8, 2512, 10),
woosh.Token(woosh.NAME, 'is_tarfile', 2512, 11, 2512, 21),
woosh.Token(woosh.OP, '(', 2512, 21, 2512, 22),
woosh.Token(woosh.NAME, 'src', 2512, 22, 2512, 25),
woosh.Token(woosh.OP, ')', 2512, 25, 2512, 26),
woosh.Token(woosh.OP, ':', 2512, 26, 2512, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 2512, 27, 2513, 0),
woosh.Token(woosh.INDENT, ' ', 2513, 0, 2513, 12),
woosh.Token(woosh.NAME, 'with', 2513, 12, 2513, 16),
woosh.Token(woosh.NAME, 'open', 2513, 17, 2513, 21),
woosh.Token(woosh.OP, '(', 2513, 21, 2513, 22),
woosh.Token(woosh.NAME, 'src', 2513, 22, 2513, 25),
woosh.Token(woosh.OP, ',', 2513, 25, 2513, 26),
woosh.Token(woosh.STRING, "'r'", 2513, 27, 2513, 30),
woosh.Token(woosh.OP, ')', 2513, 30, 2513, 31),
woosh.Token(woosh.NAME, 'as', 2513, 32, 2513, 34),
woosh.Token(woosh.NAME, 'tar', 2513, 35, 2513, 38),
woosh.Token(woosh.OP, ':', 2513, 38, 2513, 39),
woosh.Token(woosh.NEWLINE, '\r\n', 2513, 39, 2514, 0),
woosh.Token(woosh.INDENT, ' ', 2514, 0, 2514, 16),
woosh.Token(woosh.NAME, 'tar', 2514, 16, 2514, 19),
woosh.Token(woosh.OP, '.', 2514, 19, 2514, 20),
woosh.Token(woosh.NAME, 'getmembers', 2514, 20, 2514, 30),
woosh.Token(woosh.OP, '(', 2514, 30, 2514, 31),
woosh.Token(woosh.OP, ')', 2514, 31, 2514, 32),
woosh.Token(woosh.NEWLINE, '\r\n', 2514, 32, 2515, 0),
woosh.Token(woosh.NAME, 'print', 2515, 16, 2515, 21),
woosh.Token(woosh.OP, '(', 2515, 21, 2515, 22),
woosh.Token(woosh.NAME, 'tar', 2515, 22, 2515, 25),
woosh.Token(woosh.OP, '.', 2515, 25, 2515, 26),
woosh.Token(woosh.NAME, 'getmembers', 2515, 26, 2515, 36),
woosh.Token(woosh.OP, '(', 2515, 36, 2515, 37),
woosh.Token(woosh.OP, ')', 2515, 37, 2515, 38),
woosh.Token(woosh.OP, ',', 2515, 38, 2515, 39),
woosh.Token(woosh.NAME, 'file', 2515, 40, 2515, 44),
woosh.Token(woosh.OP, '=', 2515, 44, 2515, 45),
woosh.Token(woosh.NAME, 'sys', 2515, 45, 2515, 48),
woosh.Token(woosh.OP, '.', 2515, 48, 2515, 49),
woosh.Token(woosh.NAME, 'stderr', 2515, 49, 2515, 55),
woosh.Token(woosh.OP, ')', 2515, 55, 2515, 56),
woosh.Token(woosh.NEWLINE, '\r\n', 2515, 56, 2516, 0),
woosh.Token(woosh.DEDENT, ' ', 2516, 0, 2516, 12),
woosh.Token(woosh.NAME, 'if', 2516, 12, 2516, 14),
woosh.Token(woosh.NAME, 'args', 2516, 15, 2516, 19),
woosh.Token(woosh.OP, '.', 2516, 19, 2516, 20),
woosh.Token(woosh.NAME, 'verbose', 2516, 20, 2516, 27),
woosh.Token(woosh.OP, ':', 2516, 27, 2516, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 2516, 28, 2517, 0),
woosh.Token(woosh.INDENT, ' ', 2517, 0, 2517, 16),
woosh.Token(woosh.NAME, 'print', 2517, 16, 2517, 21),
woosh.Token(woosh.OP, '(', 2517, 21, 2517, 22),
woosh.Token(woosh.STRING, "'{!r} is a tar archive.'", 2517, 22, 2517, 46),
woosh.Token(woosh.OP, '.', 2517, 46, 2517, 47),
woosh.Token(woosh.NAME, 'format', 2517, 47, 2517, 53),
woosh.Token(woosh.OP, '(', 2517, 53, 2517, 54),
woosh.Token(woosh.NAME, 'src', 2517, 54, 2517, 57),
woosh.Token(woosh.OP, ')', 2517, 57, 2517, 58),
woosh.Token(woosh.OP, ')', 2517, 58, 2517, 59),
woosh.Token(woosh.NEWLINE, '\r\n', 2517, 59, 2518, 0),
woosh.Token(woosh.DEDENT, ' ', 2518, 0, 2518, 8),
woosh.Token(woosh.DEDENT, '', 2518, 8, 2518, 8),
woosh.Token(woosh.NAME, 'else', 2518, 8, 2518, 12),
woosh.Token(woosh.OP, ':', 2518, 12, 2518, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 2518, 13, 2519, 0),
woosh.Token(woosh.INDENT, ' ', 2519, 0, 2519, 12),
woosh.Token(woosh.NAME, 'parser', 2519, 12, 2519, 18),
woosh.Token(woosh.OP, '.', 2519, 18, 2519, 19),
woosh.Token(woosh.NAME, 'exit', 2519, 19, 2519, 23),
woosh.Token(woosh.OP, '(', 2519, 23, 2519, 24),
woosh.Token(woosh.NUMBER, '1', 2519, 24, 2519, 25),
woosh.Token(woosh.OP, ',', 2519, 25, 2519, 26),
woosh.Token(woosh.STRING, "'{!r} is not a tar archive.\\n'", 2519, 27, 2519, 57),
woosh.Token(woosh.OP, '.', 2519, 57, 2519, 58),
woosh.Token(woosh.NAME, 'format', 2519, 58, 2519, 64),
woosh.Token(woosh.OP, '(', 2519, 64, 2519, 65),
woosh.Token(woosh.NAME, 'src', 2519, 65, 2519, 68),
woosh.Token(woosh.OP, ')', 2519, 68, 2519, 69),
woosh.Token(woosh.OP, ')', 2519, 69, 2519, 70),
woosh.Token(woosh.NEWLINE, '\r\n', 2519, 70, 2520, 0),
woosh.Token(woosh.DEDENT, ' ', 2521, 0, 2521, 4),
woosh.Token(woosh.DEDENT, '', 2521, 4, 2521, 4),
woosh.Token(woosh.NAME, 'elif', 2521, 4, 2521, 8),
woosh.Token(woosh.NAME, 'args', 2521, 9, 2521, 13),
woosh.Token(woosh.OP, '.', 2521, 13, 2521, 14),
woosh.Token(woosh.NAME, 'list', 2521, 14, 2521, 18),
woosh.Token(woosh.NAME, 'is', 2521, 19, 2521, 21),
woosh.Token(woosh.NAME, 'not', 2521, 22, 2521, 25),
woosh.Token(woosh.NAME, 'None', 2521, 26, 2521, 30),
woosh.Token(woosh.OP, ':', 2521, 30, 2521, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 2521, 31, 2522, 0),
woosh.Token(woosh.INDENT, ' ', 2522, 0, 2522, 8),
woosh.Token(woosh.NAME, 'src', 2522, 8, 2522, 11),
woosh.Token(woosh.OP, '=', 2522, 12, 2522, 13),
woosh.Token(woosh.NAME, 'args', 2522, 14, 2522, 18),
woosh.Token(woosh.OP, '.', 2522, 18, 2522, 19),
woosh.Token(woosh.NAME, 'list', 2522, 19, 2522, 23),
woosh.Token(woosh.NEWLINE, '\r\n', 2522, 23, 2523, 0),
woosh.Token(woosh.NAME, 'if', 2523, 8, 2523, 10),
woosh.Token(woosh.NAME, 'is_tarfile', 2523, 11, 2523, 21),
woosh.Token(woosh.OP, '(', 2523, 21, 2523, 22),
woosh.Token(woosh.NAME, 'src', 2523, 22, 2523, 25),
woosh.Token(woosh.OP, ')', 2523, 25, 2523, 26),
woosh.Token(woosh.OP, ':', 2523, 26, 2523, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 2523, 27, 2524, 0),
woosh.Token(woosh.INDENT, ' ', 2524, 0, 2524, 12),
woosh.Token(woosh.NAME, 'with', 2524, 12, 2524, 16),
woosh.Token(woosh.NAME, 'TarFile', 2524, 17, 2524, 24),
woosh.Token(woosh.OP, '.', 2524, 24, 2524, 25),
woosh.Token(woosh.NAME, 'open', 2524, 25, 2524, 29),
woosh.Token(woosh.OP, '(', 2524, 29, 2524, 30),
woosh.Token(woosh.NAME, 'src', 2524, 30, 2524, 33),
woosh.Token(woosh.OP, ',', 2524, 33, 2524, 34),
woosh.Token(woosh.STRING, "'r:*'", 2524, 35, 2524, 40),
woosh.Token(woosh.OP, ')', 2524, 40, 2524, 41),
woosh.Token(woosh.NAME, 'as', 2524, 42, 2524, 44),
woosh.Token(woosh.NAME, 'tf', 2524, 45, 2524, 47),
woosh.Token(woosh.OP, ':', 2524, 47, 2524, 48),
woosh.Token(woosh.NEWLINE, '\r\n', 2524, 48, 2525, 0),
woosh.Token(woosh.INDENT, ' ', 2525, 0, 2525, 16),
woosh.Token(woosh.NAME, 'tf', 2525, 16, 2525, 18),
woosh.Token(woosh.OP, '.', 2525, 18, 2525, 19),
woosh.Token(woosh.NAME, 'list', 2525, 19, 2525, 23),
woosh.Token(woosh.OP, '(', 2525, 23, 2525, 24),
woosh.Token(woosh.NAME, 'verbose', 2525, 24, 2525, 31),
woosh.Token(woosh.OP, '=', 2525, 31, 2525, 32),
woosh.Token(woosh.NAME, 'args', 2525, 32, 2525, 36),
woosh.Token(woosh.OP, '.', 2525, 36, 2525, 37),
woosh.Token(woosh.NAME, 'verbose', 2525, 37, 2525, 44),
woosh.Token(woosh.OP, ')', 2525, 44, 2525, 45),
woosh.Token(woosh.NEWLINE, '\r\n', 2525, 45, 2526, 0),
woosh.Token(woosh.DEDENT, ' ', 2526, 0, 2526, 8),
woosh.Token(woosh.DEDENT, '', 2526, 8, 2526, 8),
woosh.Token(woosh.NAME, 'else', 2526, 8, 2526, 12),
woosh.Token(woosh.OP, ':', 2526, 12, 2526, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 2526, 13, 2527, 0),
woosh.Token(woosh.INDENT, ' ', 2527, 0, 2527, 12),
woosh.Token(woosh.NAME, 'parser', 2527, 12, 2527, 18),
woosh.Token(woosh.OP, '.', 2527, 18, 2527, 19),
woosh.Token(woosh.NAME, 'exit', 2527, 19, 2527, 23),
woosh.Token(woosh.OP, '(', 2527, 23, 2527, 24),
woosh.Token(woosh.NUMBER, '1', 2527, 24, 2527, 25),
woosh.Token(woosh.OP, ',', 2527, 25, 2527, 26),
woosh.Token(woosh.STRING, "'{!r} is not a tar archive.\\n'", 2527, 27, 2527, 57),
woosh.Token(woosh.OP, '.', 2527, 57, 2527, 58),
woosh.Token(woosh.NAME, 'format', 2527, 58, 2527, 64),
woosh.Token(woosh.OP, '(', 2527, 64, 2527, 65),
woosh.Token(woosh.NAME, 'src', 2527, 65, 2527, 68),
woosh.Token(woosh.OP, ')', 2527, 68, 2527, 69),
woosh.Token(woosh.OP, ')', 2527, 69, 2527, 70),
woosh.Token(woosh.NEWLINE, '\r\n', 2527, 70, 2528, 0),
woosh.Token(woosh.DEDENT, ' ', 2529, 0, 2529, 4),
woosh.Token(woosh.DEDENT, '', 2529, 4, 2529, 4),
woosh.Token(woosh.NAME, 'elif', 2529, 4, 2529, 8),
woosh.Token(woosh.NAME, 'args', 2529, 9, 2529, 13),
woosh.Token(woosh.OP, '.', 2529, 13, 2529, 14),
woosh.Token(woosh.NAME, 'extract', 2529, 14, 2529, 21),
woosh.Token(woosh.NAME, 'is', 2529, 22, 2529, 24),
woosh.Token(woosh.NAME, 'not', 2529, 25, 2529, 28),
woosh.Token(woosh.NAME, 'None', 2529, 29, 2529, 33),
woosh.Token(woosh.OP, ':', 2529, 33, 2529, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 2529, 34, 2530, 0),
woosh.Token(woosh.INDENT, ' ', 2530, 0, 2530, 8),
woosh.Token(woosh.NAME, 'if', 2530, 8, 2530, 10),
woosh.Token(woosh.NAME, 'len', 2530, 11, 2530, 14),
woosh.Token(woosh.OP, '(', 2530, 14, 2530, 15),
woosh.Token(woosh.NAME, 'args', 2530, 15, 2530, 19),
woosh.Token(woosh.OP, '.', 2530, 19, 2530, 20),
woosh.Token(woosh.NAME, 'extract', 2530, 20, 2530, 27),
woosh.Token(woosh.OP, ')', 2530, 27, 2530, 28),
woosh.Token(woosh.OP, '==', 2530, 29, 2530, 31),
woosh.Token(woosh.NUMBER, '1', 2530, 32, 2530, 33),
woosh.Token(woosh.OP, ':', 2530, 33, 2530, 34),
woosh.Token(woosh.NEWLINE, '\r\n', 2530, 34, 2531, 0),
woosh.Token(woosh.INDENT, ' ', 2531, 0, 2531, 12),
woosh.Token(woosh.NAME, 'src', 2531, 12, 2531, 15),
woosh.Token(woosh.OP, '=', 2531, 16, 2531, 17),
woosh.Token(woosh.NAME, 'args', 2531, 18, 2531, 22),
woosh.Token(woosh.OP, '.', 2531, 22, 2531, 23),
woosh.Token(woosh.NAME, 'extract', 2531, 23, 2531, 30),
woosh.Token(woosh.OP, '[', 2531, 30, 2531, 31),
woosh.Token(woosh.NUMBER, '0', 2531, 31, 2531, 32),
woosh.Token(woosh.OP, ']', 2531, 32, 2531, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 2531, 33, 2532, 0),
woosh.Token(woosh.NAME, 'curdir', 2532, 12, 2532, 18),
woosh.Token(woosh.OP, '=', 2532, 19, 2532, 20),
woosh.Token(woosh.NAME, 'os', 2532, 21, 2532, 23),
woosh.Token(woosh.OP, '.', 2532, 23, 2532, 24),
woosh.Token(woosh.NAME, 'curdir', 2532, 24, 2532, 30),
woosh.Token(woosh.NEWLINE, '\r\n', 2532, 30, 2533, 0),
woosh.Token(woosh.DEDENT, ' ', 2533, 0, 2533, 8),
woosh.Token(woosh.NAME, 'elif', 2533, 8, 2533, 12),
woosh.Token(woosh.NAME, 'len', 2533, 13, 2533, 16),
woosh.Token(woosh.OP, '(', 2533, 16, 2533, 17),
woosh.Token(woosh.NAME, 'args', 2533, 17, 2533, 21),
woosh.Token(woosh.OP, '.', 2533, 21, 2533, 22),
woosh.Token(woosh.NAME, 'extract', 2533, 22, 2533, 29),
woosh.Token(woosh.OP, ')', 2533, 29, 2533, 30),
woosh.Token(woosh.OP, '==', 2533, 31, 2533, 33),
woosh.Token(woosh.NUMBER, '2', 2533, 34, 2533, 35),
woosh.Token(woosh.OP, ':', 2533, 35, 2533, 36),
woosh.Token(woosh.NEWLINE, '\r\n', 2533, 36, 2534, 0),
woosh.Token(woosh.INDENT, ' ', 2534, 0, 2534, 12),
woosh.Token(woosh.NAME, 'src', 2534, 12, 2534, 15),
woosh.Token(woosh.OP, ',', 2534, 15, 2534, 16),
woosh.Token(woosh.NAME, 'curdir', 2534, 17, 2534, 23),
woosh.Token(woosh.OP, '=', 2534, 24, 2534, 25),
woosh.Token(woosh.NAME, 'args', 2534, 26, 2534, 30),
woosh.Token(woosh.OP, '.', 2534, 30, 2534, 31),
woosh.Token(woosh.NAME, 'extract', 2534, 31, 2534, 38),
woosh.Token(woosh.NEWLINE, '\r\n', 2534, 38, 2535, 0),
woosh.Token(woosh.DEDENT, ' ', 2535, 0, 2535, 8),
woosh.Token(woosh.NAME, 'else', 2535, 8, 2535, 12),
woosh.Token(woosh.OP, ':', 2535, 12, 2535, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 2535, 13, 2536, 0),
woosh.Token(woosh.INDENT, ' ', 2536, 0, 2536, 12),
woosh.Token(woosh.NAME, 'parser', 2536, 12, 2536, 18),
woosh.Token(woosh.OP, '.', 2536, 18, 2536, 19),
woosh.Token(woosh.NAME, 'exit', 2536, 19, 2536, 23),
woosh.Token(woosh.OP, '(', 2536, 23, 2536, 24),
woosh.Token(woosh.NUMBER, '1', 2536, 24, 2536, 25),
woosh.Token(woosh.OP, ',', 2536, 25, 2536, 26),
woosh.Token(woosh.NAME, 'parser', 2536, 27, 2536, 33),
woosh.Token(woosh.OP, '.', 2536, 33, 2536, 34),
woosh.Token(woosh.NAME, 'format_help', 2536, 34, 2536, 45),
woosh.Token(woosh.OP, '(', 2536, 45, 2536, 46),
woosh.Token(woosh.OP, ')', 2536, 46, 2536, 47),
woosh.Token(woosh.OP, ')', 2536, 47, 2536, 48),
woosh.Token(woosh.NEWLINE, '\r\n', 2536, 48, 2537, 0),
woosh.Token(woosh.DEDENT, ' ', 2538, 0, 2538, 8),
woosh.Token(woosh.NAME, 'if', 2538, 8, 2538, 10),
woosh.Token(woosh.NAME, 'is_tarfile', 2538, 11, 2538, 21),
woosh.Token(woosh.OP, '(', 2538, 21, 2538, 22),
woosh.Token(woosh.NAME, 'src', 2538, 22, 2538, 25),
woosh.Token(woosh.OP, ')', 2538, 25, 2538, 26),
woosh.Token(woosh.OP, ':', 2538, 26, 2538, 27),
woosh.Token(woosh.NEWLINE, '\r\n', 2538, 27, 2539, 0),
woosh.Token(woosh.INDENT, ' ', 2539, 0, 2539, 12),
woosh.Token(woosh.NAME, 'with', 2539, 12, 2539, 16),
woosh.Token(woosh.NAME, 'TarFile', 2539, 17, 2539, 24),
woosh.Token(woosh.OP, '.', 2539, 24, 2539, 25),
woosh.Token(woosh.NAME, 'open', 2539, 25, 2539, 29),
woosh.Token(woosh.OP, '(', 2539, 29, 2539, 30),
woosh.Token(woosh.NAME, 'src', 2539, 30, 2539, 33),
woosh.Token(woosh.OP, ',', 2539, 33, 2539, 34),
woosh.Token(woosh.STRING, "'r:*'", 2539, 35, 2539, 40),
woosh.Token(woosh.OP, ')', 2539, 40, 2539, 41),
woosh.Token(woosh.NAME, 'as', 2539, 42, 2539, 44),
woosh.Token(woosh.NAME, 'tf', 2539, 45, 2539, 47),
woosh.Token(woosh.OP, ':', 2539, 47, 2539, 48),
woosh.Token(woosh.NEWLINE, '\r\n', 2539, 48, 2540, 0),
woosh.Token(woosh.INDENT, ' ', 2540, 0, 2540, 16),
woosh.Token(woosh.NAME, 'tf', 2540, 16, 2540, 18),
woosh.Token(woosh.OP, '.', 2540, 18, 2540, 19),
woosh.Token(woosh.NAME, 'extractall', 2540, 19, 2540, 29),
woosh.Token(woosh.OP, '(', 2540, 29, 2540, 30),
woosh.Token(woosh.NAME, 'path', 2540, 30, 2540, 34),
woosh.Token(woosh.OP, '=', 2540, 34, 2540, 35),
woosh.Token(woosh.NAME, 'curdir', 2540, 35, 2540, 41),
woosh.Token(woosh.OP, ')', 2540, 41, 2540, 42),
woosh.Token(woosh.NEWLINE, '\r\n', 2540, 42, 2541, 0),
woosh.Token(woosh.DEDENT, ' ', 2541, 0, 2541, 12),
woosh.Token(woosh.NAME, 'if', 2541, 12, 2541, 14),
woosh.Token(woosh.NAME, 'args', 2541, 15, 2541, 19),
woosh.Token(woosh.OP, '.', 2541, 19, 2541, 20),
woosh.Token(woosh.NAME, 'verbose', 2541, 20, 2541, 27),
woosh.Token(woosh.OP, ':', 2541, 27, 2541, 28),
woosh.Token(woosh.NEWLINE, '\r\n', 2541, 28, 2542, 0),
woosh.Token(woosh.INDENT, ' ', 2542, 0, 2542, 16),
woosh.Token(woosh.NAME, 'if', 2542, 16, 2542, 18),
woosh.Token(woosh.NAME, 'curdir', 2542, 19, 2542, 25),
woosh.Token(woosh.OP, '==', 2542, 26, 2542, 28),
woosh.Token(woosh.STRING, "'.'", 2542, 29, 2542, 32),
woosh.Token(woosh.OP, ':', 2542, 32, 2542, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 2542, 33, 2543, 0),
woosh.Token(woosh.INDENT, ' ', 2543, 0, 2543, 20),
woosh.Token(woosh.NAME, 'msg', 2543, 20, 2543, 23),
woosh.Token(woosh.OP, '=', 2543, 24, 2543, 25),
woosh.Token(woosh.STRING, "'{!r} file is extracted.'", 2543, 26, 2543, 51),
woosh.Token(woosh.OP, '.', 2543, 51, 2543, 52),
woosh.Token(woosh.NAME, 'format', 2543, 52, 2543, 58),
woosh.Token(woosh.OP, '(', 2543, 58, 2543, 59),
woosh.Token(woosh.NAME, 'src', 2543, 59, 2543, 62),
woosh.Token(woosh.OP, ')', 2543, 62, 2543, 63),
woosh.Token(woosh.NEWLINE, '\r\n', 2543, 63, 2544, 0),
woosh.Token(woosh.DEDENT, ' ', 2544, 0, 2544, 16),
woosh.Token(woosh.NAME, 'else', 2544, 16, 2544, 20),
woosh.Token(woosh.OP, ':', 2544, 20, 2544, 21),
woosh.Token(woosh.NEWLINE, '\r\n', 2544, 21, 2545, 0),
woosh.Token(woosh.INDENT, ' ', 2545, 0, 2545, 20),
woosh.Token(woosh.NAME, 'msg', 2545, 20, 2545, 23),
woosh.Token(woosh.OP, '=', 2545, 24, 2545, 25),
woosh.Token(woosh.OP, '(', 2545, 26, 2545, 27),
woosh.Token(woosh.STRING, "'{!r} file is extracted '", 2545, 27, 2545, 52),
woosh.Token(woosh.STRING, "'into {!r} directory.'", 2546, 27, 2546, 49),
woosh.Token(woosh.OP, ')', 2546, 49, 2546, 50),
woosh.Token(woosh.OP, '.', 2546, 50, 2546, 51),
woosh.Token(woosh.NAME, 'format', 2546, 51, 2546, 57),
woosh.Token(woosh.OP, '(', 2546, 57, 2546, 58),
woosh.Token(woosh.NAME, 'src', 2546, 58, 2546, 61),
woosh.Token(woosh.OP, ',', 2546, 61, 2546, 62),
woosh.Token(woosh.NAME, 'curdir', 2546, 63, 2546, 69),
woosh.Token(woosh.OP, ')', 2546, 69, 2546, 70),
woosh.Token(woosh.NEWLINE, '\r\n', 2546, 70, 2547, 0),
woosh.Token(woosh.DEDENT, ' ', 2547, 0, 2547, 16),
woosh.Token(woosh.NAME, 'print', 2547, 16, 2547, 21),
woosh.Token(woosh.OP, '(', 2547, 21, 2547, 22),
woosh.Token(woosh.NAME, 'msg', 2547, 22, 2547, 25),
woosh.Token(woosh.OP, ')', 2547, 25, 2547, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 2547, 26, 2548, 0),
woosh.Token(woosh.DEDENT, ' ', 2548, 0, 2548, 8),
woosh.Token(woosh.DEDENT, '', 2548, 8, 2548, 8),
woosh.Token(woosh.NAME, 'else', 2548, 8, 2548, 12),
woosh.Token(woosh.OP, ':', 2548, 12, 2548, 13),
woosh.Token(woosh.NEWLINE, '\r\n', 2548, 13, 2549, 0),
woosh.Token(woosh.INDENT, ' ', 2549, 0, 2549, 12),
woosh.Token(woosh.NAME, 'parser', 2549, 12, 2549, 18),
woosh.Token(woosh.OP, '.', 2549, 18, 2549, 19),
woosh.Token(woosh.NAME, 'exit', 2549, 19, 2549, 23),
woosh.Token(woosh.OP, '(', 2549, 23, 2549, 24),
woosh.Token(woosh.NUMBER, '1', 2549, 24, 2549, 25),
woosh.Token(woosh.OP, ',', 2549, 25, 2549, 26),
woosh.Token(woosh.STRING, "'{!r} is not a tar archive.\\n'", 2549, 27, 2549, 57),
woosh.Token(woosh.OP, '.', 2549, 57, 2549, 58),
woosh.Token(woosh.NAME, 'format', 2549, 58, 2549, 64),
woosh.Token(woosh.OP, '(', 2549, 64, 2549, 65),
woosh.Token(woosh.NAME, 'src', 2549, 65, 2549, 68),
woosh.Token(woosh.OP, ')', 2549, 68, 2549, 69),
woosh.Token(woosh.OP, ')', 2549, 69, 2549, 70),
woosh.Token(woosh.NEWLINE, '\r\n', 2549, 70, 2550, 0),
woosh.Token(woosh.DEDENT, ' ', 2551, 0, 2551, 4),
woosh.Token(woosh.DEDENT, '', 2551, 4, 2551, 4),
woosh.Token(woosh.NAME, 'elif', 2551, 4, 2551, 8),
woosh.Token(woosh.NAME, 'args', 2551, 9, 2551, 13),
woosh.Token(woosh.OP, '.', 2551, 13, 2551, 14),
woosh.Token(woosh.NAME, 'create', 2551, 14, 2551, 20),
woosh.Token(woosh.NAME, 'is', 2551, 21, 2551, 23),
woosh.Token(woosh.NAME, 'not', 2551, 24, 2551, 27),
woosh.Token(woosh.NAME, 'None', 2551, 28, 2551, 32),
woosh.Token(woosh.OP, ':', 2551, 32, 2551, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 2551, 33, 2552, 0),
woosh.Token(woosh.INDENT, ' ', 2552, 0, 2552, 8),
woosh.Token(woosh.NAME, 'tar_name', 2552, 8, 2552, 16),
woosh.Token(woosh.OP, '=', 2552, 17, 2552, 18),
woosh.Token(woosh.NAME, 'args', 2552, 19, 2552, 23),
woosh.Token(woosh.OP, '.', 2552, 23, 2552, 24),
woosh.Token(woosh.NAME, 'create', 2552, 24, 2552, 30),
woosh.Token(woosh.OP, '.', 2552, 30, 2552, 31),
woosh.Token(woosh.NAME, 'pop', 2552, 31, 2552, 34),
woosh.Token(woosh.OP, '(', 2552, 34, 2552, 35),
woosh.Token(woosh.NUMBER, '0', 2552, 35, 2552, 36),
woosh.Token(woosh.OP, ')', 2552, 36, 2552, 37),
woosh.Token(woosh.NEWLINE, '\r\n', 2552, 37, 2553, 0),
woosh.Token(woosh.NAME, '_', 2553, 8, 2553, 9),
woosh.Token(woosh.OP, ',', 2553, 9, 2553, 10),
woosh.Token(woosh.NAME, 'ext', 2553, 11, 2553, 14),
woosh.Token(woosh.OP, '=', 2553, 15, 2553, 16),
woosh.Token(woosh.NAME, 'os', 2553, 17, 2553, 19),
woosh.Token(woosh.OP, '.', 2553, 19, 2553, 20),
woosh.Token(woosh.NAME, 'path', 2553, 20, 2553, 24),
woosh.Token(woosh.OP, '.', 2553, 24, 2553, 25),
woosh.Token(woosh.NAME, 'splitext', 2553, 25, 2553, 33),
woosh.Token(woosh.OP, '(', 2553, 33, 2553, 34),
woosh.Token(woosh.NAME, 'tar_name', 2553, 34, 2553, 42),
woosh.Token(woosh.OP, ')', 2553, 42, 2553, 43),
woosh.Token(woosh.NEWLINE, '\r\n', 2553, 43, 2554, 0),
woosh.Token(woosh.NAME, 'compressions', 2554, 8, 2554, 20),
woosh.Token(woosh.OP, '=', 2554, 21, 2554, 22),
woosh.Token(woosh.OP, '{', 2554, 23, 2554, 24),
woosh.Token(woosh.COMMENT, '# gz', 2555, 12, 2555, 16),
woosh.Token(woosh.STRING, "'.gz'", 2556, 12, 2556, 17),
woosh.Token(woosh.OP, ':', 2556, 17, 2556, 18),
woosh.Token(woosh.STRING, "'gz'", 2556, 19, 2556, 23),
woosh.Token(woosh.OP, ',', 2556, 23, 2556, 24),
woosh.Token(woosh.STRING, "'.tgz'", 2557, 12, 2557, 18),
woosh.Token(woosh.OP, ':', 2557, 18, 2557, 19),
woosh.Token(woosh.STRING, "'gz'", 2557, 20, 2557, 24),
woosh.Token(woosh.OP, ',', 2557, 24, 2557, 25),
woosh.Token(woosh.COMMENT, '# xz', 2558, 12, 2558, 16),
woosh.Token(woosh.STRING, "'.xz'", 2559, 12, 2559, 17),
woosh.Token(woosh.OP, ':', 2559, 17, 2559, 18),
woosh.Token(woosh.STRING, "'xz'", 2559, 19, 2559, 23),
woosh.Token(woosh.OP, ',', 2559, 23, 2559, 24),
woosh.Token(woosh.STRING, "'.txz'", 2560, 12, 2560, 18),
woosh.Token(woosh.OP, ':', 2560, 18, 2560, 19),
woosh.Token(woosh.STRING, "'xz'", 2560, 20, 2560, 24),
woosh.Token(woosh.OP, ',', 2560, 24, 2560, 25),
woosh.Token(woosh.COMMENT, '# bz2', 2561, 12, 2561, 17),
woosh.Token(woosh.STRING, "'.bz2'", 2562, 12, 2562, 18),
woosh.Token(woosh.OP, ':', 2562, 18, 2562, 19),
woosh.Token(woosh.STRING, "'bz2'", 2562, 20, 2562, 25),
woosh.Token(woosh.OP, ',', 2562, 25, 2562, 26),
woosh.Token(woosh.STRING, "'.tbz'", 2563, 12, 2563, 18),
woosh.Token(woosh.OP, ':', 2563, 18, 2563, 19),
woosh.Token(woosh.STRING, "'bz2'", 2563, 20, 2563, 25),
woosh.Token(woosh.OP, ',', 2563, 25, 2563, 26),
woosh.Token(woosh.STRING, "'.tbz2'", 2564, 12, 2564, 19),
woosh.Token(woosh.OP, ':', 2564, 19, 2564, 20),
woosh.Token(woosh.STRING, "'bz2'", 2564, 21, 2564, 26),
woosh.Token(woosh.OP, ',', 2564, 26, 2564, 27),
woosh.Token(woosh.STRING, "'.tb2'", 2565, 12, 2565, 18),
woosh.Token(woosh.OP, ':', 2565, 18, 2565, 19),
woosh.Token(woosh.STRING, "'bz2'", 2565, 20, 2565, 25),
woosh.Token(woosh.OP, ',', 2565, 25, 2565, 26),
woosh.Token(woosh.OP, '}', 2566, 8, 2566, 9),
woosh.Token(woosh.NEWLINE, '\r\n', 2566, 9, 2567, 0),
woosh.Token(woosh.NAME, 'tar_mode', 2567, 8, 2567, 16),
woosh.Token(woosh.OP, '=', 2567, 17, 2567, 18),
woosh.Token(woosh.STRING, "'w:'", 2567, 19, 2567, 23),
woosh.Token(woosh.OP, '+', 2567, 24, 2567, 25),
woosh.Token(woosh.NAME, 'compressions', 2567, 26, 2567, 38),
woosh.Token(woosh.OP, '[', 2567, 38, 2567, 39),
woosh.Token(woosh.NAME, 'ext', 2567, 39, 2567, 42),
woosh.Token(woosh.OP, ']', 2567, 42, 2567, 43),
woosh.Token(woosh.NAME, 'if', 2567, 44, 2567, 46),
woosh.Token(woosh.NAME, 'ext', 2567, 47, 2567, 50),
woosh.Token(woosh.NAME, 'in', 2567, 51, 2567, 53),
woosh.Token(woosh.NAME, 'compressions', 2567, 54, 2567, 66),
woosh.Token(woosh.NAME, 'else', 2567, 67, 2567, 71),
woosh.Token(woosh.STRING, "'w'", 2567, 72, 2567, 75),
woosh.Token(woosh.NEWLINE, '\r\n', 2567, 75, 2568, 0),
woosh.Token(woosh.NAME, 'tar_files', 2568, 8, 2568, 17),
woosh.Token(woosh.OP, '=', 2568, 18, 2568, 19),
woosh.Token(woosh.NAME, 'args', 2568, 20, 2568, 24),
woosh.Token(woosh.OP, '.', 2568, 24, 2568, 25),
woosh.Token(woosh.NAME, 'create', 2568, 25, 2568, 31),
woosh.Token(woosh.NEWLINE, '\r\n', 2568, 31, 2569, 0),
woosh.Token(woosh.NAME, 'with', 2570, 8, 2570, 12),
woosh.Token(woosh.NAME, 'TarFile', 2570, 13, 2570, 20),
woosh.Token(woosh.OP, '.', 2570, 20, 2570, 21),
woosh.Token(woosh.NAME, 'open', 2570, 21, 2570, 25),
woosh.Token(woosh.OP, '(', 2570, 25, 2570, 26),
woosh.Token(woosh.NAME, 'tar_name', 2570, 26, 2570, 34),
woosh.Token(woosh.OP, ',', 2570, 34, 2570, 35),
woosh.Token(woosh.NAME, 'tar_mode', 2570, 36, 2570, 44),
woosh.Token(woosh.OP, ')', 2570, 44, 2570, 45),
woosh.Token(woosh.NAME, 'as', 2570, 46, 2570, 48),
woosh.Token(woosh.NAME, 'tf', 2570, 49, 2570, 51),
woosh.Token(woosh.OP, ':', 2570, 51, 2570, 52),
woosh.Token(woosh.NEWLINE, '\r\n', 2570, 52, 2571, 0),
woosh.Token(woosh.INDENT, ' ', 2571, 0, 2571, 12),
woosh.Token(woosh.NAME, 'for', 2571, 12, 2571, 15),
woosh.Token(woosh.NAME, 'file_name', 2571, 16, 2571, 25),
woosh.Token(woosh.NAME, 'in', 2571, 26, 2571, 28),
woosh.Token(woosh.NAME, 'tar_files', 2571, 29, 2571, 38),
woosh.Token(woosh.OP, ':', 2571, 38, 2571, 39),
woosh.Token(woosh.NEWLINE, '\r\n', 2571, 39, 2572, 0),
woosh.Token(woosh.INDENT, ' ', 2572, 0, 2572, 16),
woosh.Token(woosh.NAME, 'tf', 2572, 16, 2572, 18),
woosh.Token(woosh.OP, '.', 2572, 18, 2572, 19),
woosh.Token(woosh.NAME, 'add', 2572, 19, 2572, 22),
woosh.Token(woosh.OP, '(', 2572, 22, 2572, 23),
woosh.Token(woosh.NAME, 'file_name', 2572, 23, 2572, 32),
woosh.Token(woosh.OP, ')', 2572, 32, 2572, 33),
woosh.Token(woosh.NEWLINE, '\r\n', 2572, 33, 2573, 0),
woosh.Token(woosh.DEDENT, ' ', 2574, 0, 2574, 8),
woosh.Token(woosh.DEDENT, '', 2574, 8, 2574, 8),
woosh.Token(woosh.NAME, 'if', 2574, 8, 2574, 10),
woosh.Token(woosh.NAME, 'args', 2574, 11, 2574, 15),
woosh.Token(woosh.OP, '.', 2574, 15, 2574, 16),
woosh.Token(woosh.NAME, 'verbose', 2574, 16, 2574, 23),
woosh.Token(woosh.OP, ':', 2574, 23, 2574, 24),
woosh.Token(woosh.NEWLINE, '\r\n', 2574, 24, 2575, 0),
woosh.Token(woosh.INDENT, ' ', 2575, 0, 2575, 12),
woosh.Token(woosh.NAME, 'print', 2575, 12, 2575, 17),
woosh.Token(woosh.OP, '(', 2575, 17, 2575, 18),
woosh.Token(woosh.STRING, "'{!r} file created.'", 2575, 18, 2575, 38),
woosh.Token(woosh.OP, '.', 2575, 38, 2575, 39),
woosh.Token(woosh.NAME, 'format', 2575, 39, 2575, 45),
woosh.Token(woosh.OP, '(', 2575, 45, 2575, 46),
woosh.Token(woosh.NAME, 'tar_name', 2575, 46, 2575, 54),
woosh.Token(woosh.OP, ')', 2575, 54, 2575, 55),
woosh.Token(woosh.OP, ')', 2575, 55, 2575, 56),
woosh.Token(woosh.NEWLINE, '\r\n', 2575, 56, 2576, 0),
woosh.Token(woosh.DEDENT, '', 2577, 0, 2577, 0),
woosh.Token(woosh.DEDENT, '', 2577, 0, 2577, 0),
woosh.Token(woosh.DEDENT, '', 2577, 0, 2577, 0),
woosh.Token(woosh.NAME, 'if', 2577, 0, 2577, 2),
woosh.Token(woosh.NAME, '__name__', 2577, 3, 2577, 11),
woosh.Token(woosh.OP, '==', 2577, 12, 2577, 14),
woosh.Token(woosh.STRING, "'__main__'", 2577, 15, 2577, 25),
woosh.Token(woosh.OP, ':', 2577, 25, 2577, 26),
woosh.Token(woosh.NEWLINE, '\r\n', 2577, 26, 2578, 0),
woosh.Token(woosh.INDENT, ' ', 2578, 0, 2578, 4),
woosh.Token(woosh.NAME, 'main', 2578, 4, 2578, 8),
woosh.Token(woosh.OP, '(', 2578, 8, 2578, 9),
woosh.Token(woosh.OP, ')', 2578, 9, 2578, 10),
woosh.Token(woosh.NEWLINE, '\r\n', 2578, 10, 2579, 0),
woosh.Token(woosh.DEDENT, '', 2579, 0, 2579, 0),
woosh.Token(woosh.EOF, '', 2579, 0, 2579, 0),
]
| [
"stillusingirc@gmail.com"
] | stillusingirc@gmail.com |
c8ad206a40877f210ad57efa84da7431b83e0097 | 3621423618749c3ceefe34f77a405cf3f3d5a060 | /home/migrations/0001_initial.py | 84d2250d33edb34c42b26f2b968260668bfd67a9 | [] | no_license | AlvinChanM/CoolBlog | 3885c037c5cf21e22e16198388e79aca40cf51ba | 94240568b46c0e074db0038e3a3a0a6e67416fe9 | refs/heads/master | 2021-05-05T23:34:12.531895 | 2018-01-12T06:49:54 | 2018-01-12T06:49:54 | 116,800,823 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,470 | py | # -*- coding: utf-8 -*-
# Generated by Django 1.11.2 on 2018-01-09 14:13
from __future__ import unicode_literals
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
initial = True
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
]
operations = [
migrations.CreateModel(
name='Article',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('title', models.CharField(max_length=70, verbose_name='\u6587\u7ae0\u6807\u9898')),
('body', models.TextField(default='', verbose_name='\u6587\u7ae0\u5185\u5bb9')),
('created_time', models.DateTimeField(default='', verbose_name='\u521b\u5efa\u65f6\u95f4')),
('modified_time', models.DateTimeField(default='', verbose_name='\u4fee\u6539\u65f6\u95f4')),
('excerpt', models.CharField(blank=True, max_length=200, verbose_name='\u6458\u8981')),
('views', models.PositiveIntegerField(default=0, verbose_name='\u6d4f\u89c8\u91cf')),
('author', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL, verbose_name='\u4f5c\u8005')),
],
),
migrations.CreateModel(
name='Category',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(max_length=50, verbose_name='\u5206\u7c7b\u540d\u79f0')),
],
),
migrations.CreateModel(
name='Tag',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(max_length=50, verbose_name='\u6807\u7b7e\u540d\u79f0')),
],
),
migrations.AddField(
model_name='article',
name='category',
field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='home.Category', verbose_name='\u5206\u7c7b'),
),
migrations.AddField(
model_name='article',
name='tags',
field=models.ManyToManyField(blank=True, to='home.Tag', verbose_name='\u6807\u7b7e'),
),
]
| [
"miao564103484@163.com"
] | miao564103484@163.com |
7ee6ff26ba277d1c49dcf2b4bb869480975c42db | 179ee65ebe9b06aefc51f54908107c6fbbdb82f1 | /tutorial/spiders/Hadist9Spider.py | 9182f62e431193a21d4da7c19729fbe40af309a8 | [
"MIT"
] | permissive | richasdy/scrapy-tutorial | aeb722608dda9b4bd8e99856017ebc702c54dc7b | 426c1a885874a087fd49f4b5bec62653e8821744 | refs/heads/master | 2021-05-18T00:45:13.060299 | 2020-04-25T08:10:29 | 2020-04-25T08:10:29 | 251,030,286 | 0 | 0 | MIT | 2020-03-29T12:47:42 | 2020-03-29T12:47:41 | null | UTF-8 | Python | false | false | 2,033 | py | import os
import scrapy
from time import sleep
from scrapy.loader import ItemLoader
from scrapy.selector import Selector
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.keys import Keys
from scrapy_selenium import SeleniumRequest
basedir = os.path.dirname(os.path.realpath('__file__'))
class Hadist9Spider(scrapy.Spider):
# GET with JS
# https://hadits.in/malik/1
# better by ini karena ada definisi matan
# POST API
# https://hadits.in/viewer/service_eh2.php
# form-data : {"jsonrpc":"2.0","method":"getHadits","params":["malik","1"],"id":1}
# from-data : {"jsonrpc":"2.0","method":"getHadits","params":["malik","1594"],"id":1}
name = "hadist9"
allowed_domains = ["hadits.in"]
start_urls = [
'https://hadits.in/bukhari/1',
]
def parse(self, response):
chrome_options = Options()
# Preferences
# https://src.chromium.org/viewvc/chrome/trunk/src/chrome/common/pref_names.cc?view=markup
# disable image download
prefs = {"profile.managed_default_content_settings.images":2}
chrome_options.add_experimental_option('prefs', prefs)
# Arguments
# https://peter.sh/experiments/chromium-command-line-switches/
chrome_options.add_argument("--headless")
# chrome_options.add_argument("--window-size=1920x1080")
chrome_options.add_argument("--disk-cache-size=5242880")
chrome_driver_path = os.path.join(basedir, 'chromedriver')
driver = webdriver.Chrome(chrome_options=chrome_options, executable_path=chrome_driver_path)
driver.get(self.start_urls[0])
scrapy_selector = Selector(text = driver.page_source)
# print(scrapy_selector.css('.menu-wrap').get())
print('ARAB : ' + scrapy_selector.css('.ScheherazadeW::text').get())
print('INDONESIA : ' + scrapy_selector.css('.mykitab-secondary::text').get())
driver.quit()
| [
"donni.richasdy@gmail.com"
] | donni.richasdy@gmail.com |
c2113be94bd6ef86abbc7380563b0a18cabd088f | f45cc0049cd6c3a2b25de0e9bbc80c25c113a356 | /LeetCode/动态规划法(dp)/背包问题/474. 一和零.py | ee1171e6057672507a105886d84a225938f263c0 | [] | no_license | yiming1012/MyLeetCode | 4a387d024969bfd1cdccd4f581051a6e4104891a | e43ee86c5a8cdb808da09b4b6138e10275abadb5 | refs/heads/master | 2023-06-17T06:43:13.854862 | 2021-07-15T08:54:07 | 2021-07-15T08:54:07 | 261,663,876 | 2 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,788 | py | """
474. 一和零
给你一个二进制字符串数组 strs 和两个整数 m 和 n 。
请你找出并返回 strs 的最大子集的大小，该子集中 最多 有 m 个 0 和 n 个 1 。
如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的 子集 。
示例 1：
输入：strs = ["10", "0001", "111001", "1", "0"], m = 5, n = 3
输出：4
解释：最多有 5 个 0 和 3 个 1 的最大子集是 {"10","0001","1","0"} ，因此答案是 4 。
其他满足题意但较小的子集包括 {"0001","1"} 和 {"10","1","0"} 。{"111001"} 不满足题意，因为它含 4 个 1 ，大于 n 的值 3 。
示例 2：
输入：strs = ["10", "0", "1"], m = 1, n = 1
输出：2
解释：最大的子集是 {"0", "1"} ，所以答案是 2 。
提示：
1 <= strs.length <= 600
1 <= strs[i].length <= 100
strs[i] 仅由 '0' 和 '1' 组成
1 <= m, n <= 100
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/ones-and-zeroes
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
"""
from typing import List
class Solution:
def findMaxForm1(self, strs: List[str], m: int, n: int) -> int:
"""
三维dp
@param strs:
@param m:
@param n:
@return:
"""
size = len(strs)
# dp[i][j][k]:表示前i个字符串构成j个0，k个1的最大子集
dp = [[[0] * (n + 1) for _ in range(m + 1)] for _ in range(size + 1)]
for i in range(1, size + 1):
zero = strs[i - 1].count('0')
one = strs[i - 1].count('1')
for j in range(m + 1):
for k in range(n + 1):
# 这里需要从前往后赋值
dp[i][j][k] = dp[i - 1][j][k]
if j >= zero and k >= one:
dp[i][j][k] = max(dp[i - 1][j][k], dp[i - 1][j - zero][k - one] + 1)
return dp[-1][-1][-1]
def findMaxForm2(self, strs: List[str], m: int, n: int) -> int:
"""
二维
@param strs:
@param m:
@param n:
@return:
"""
size = len(strs)
# dp[i][j][k]:表示前i个字符串构成j个0，k个1的最大子集
dp = [[0] * (n + 1) for _ in range(m + 1)]
for i in range(1, size + 1):
zero = strs[i - 1].count('0')
one = strs[i - 1].count('1')
for j in range(m, zero - 1, -1):
for k in range(n, one - 1, -1):
dp[j][k] = max(dp[j][k], dp[j - zero][k - one] + 1)
return dp[-1][-1]
if __name__ == '__main__':
strs = ["10", "0001", "111001", "1", "0"]
m = 5
n = 3
print(Solution().findMaxForm1(strs, m, n))
print(Solution().findMaxForm2(strs, m, n))
| [
"1129079384@qq.com"
] | 1129079384@qq.com |
56f16db5640a5744b67e7f88a950990ad72782a6 | 21b0b4c27193898207751c91b8b2ed168a1b1638 | /py/py_0383_divisibility_comparison_between_factorials.py | 6e66399ac758ee89f0245e09912ace51ce300130 | [
"MIT"
] | permissive | lcsm29/project-euler | 67560a4e66968f1671a3d7ecf2dda6c956893dca | fab794ece5aa7a11fc7c2177f26250f40a5b1447 | refs/heads/main | 2023-07-04T11:45:24.374841 | 2021-08-07T08:20:41 | 2021-08-07T08:20:41 | 371,808,781 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 605 | py | # Solution of;
# Project Euler Problem 383: Divisibility comparison between factorials
# https://projecteuler.net/problem=383
#
# Let f5(n) be the largest integer x for which 5x divides n. For example,
# f5(625000) = 7. Let T5(n) be the number of integers i which satisfy
# f5((2·i-1)!) < 2·f5(i!) and 1 ≤ i ≤ n. It can be verified that T5(103) = 68
# and T5(109) = 2408210. Find T5(1018).
#
# by lcsm29 http://github.com/lcsm29/project-euler
import timed
def dummy(n):
pass
if __name__ == '__main__':
n = 1000
i = 10000
prob_id = 383
timed.caller(dummy, n, i, prob_id)
| [
"lcsm29@outlook.com"
] | lcsm29@outlook.com |
da31943f12cab72657cccbf301ca3e51137991fa | 6b29d66ba7927129b68bc00db769f0edf1babaea | /SoftLayer/CLI/mq/endpoints_list.py | 179663919c224900057d00eea255084ae140b781 | [
"MIT"
] | permissive | tdurden82/softlayer-python | 65f42923c347a164995dfc267829721032de261d | 0eed20fa4adedd3228d91d929bb8befb1e445e49 | refs/heads/master | 2021-01-17T10:01:48.087450 | 2015-10-19T18:38:53 | 2015-10-19T18:38:53 | 46,301,339 | 0 | 1 | null | null | null | null | UTF-8 | Python | false | false | 699 | py | """List SoftLayer Message Queue Endpoints."""
# :license: MIT, see LICENSE for more details.
import SoftLayer
from SoftLayer.CLI import environment
from SoftLayer.CLI import formatting
import click
@click.command()
@environment.pass_env
def cli(env):
"""List SoftLayer Message Queue Endpoints."""
manager = SoftLayer.MessagingManager(env.client)
regions = manager.get_endpoints()
table = formatting.Table(['name', 'public', 'private'])
for region, endpoints in regions.items():
table.add_row([
region,
endpoints.get('public') or formatting.blank(),
endpoints.get('private') or formatting.blank(),
])
env.fout(table)
| [
"k3vinmcdonald@gmail.com"
] | k3vinmcdonald@gmail.com |
92916397d8bf8d6741c6ac3a5ea1959e5458d171 | 4d87e41fa51a3f777512982553b9bf4f32325c2f | /Scripts/pip3-script.py | 7e22278ba12539d9a302792add86e495297ccf05 | [] | no_license | Leno1993/RecommendSystem | 75bc8a045abbd83a127133cac80feb3149ce2802 | c97126126e86dd309804aa7b5da8df62b6491472 | refs/heads/master | 2020-05-09T12:59:28.410270 | 2019-03-24T13:53:48 | 2019-03-24T13:53:48 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 386 | py | #!D:\PycharmWorkSpace\Scripts\python.exe
# EASY-INSTALL-ENTRY-SCRIPT: 'pip==9.0.1','console_scripts','pip3'
__requires__ = 'pip==9.0.1'
import re
import sys
from pkg_resources import load_entry_point
if __name__ == '__main__':
sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
sys.exit(
load_entry_point('pip==9.0.1', 'console_scripts', 'pip3')()
)
| [
"gaojiaming24@163.com"
] | gaojiaming24@163.com |
6cd99aa856870945383ad551d176b967727db0ba | 4851d160a423b4a65e81a75d5b4de5218de958ee | /Pig Sursurunga.py | cd4d4594217fdde6c6d1df1dd137ceb730f8f010 | [] | no_license | LarisaOvchinnikova/python_codewars | 519508e5626303dcead5ecb839c6d9b53cb3c764 | 5399f4be17e4972e61be74831703a82ce9badffd | refs/heads/master | 2023-05-05T14:52:02.100435 | 2021-05-25T18:36:51 | 2021-05-25T18:36:51 | 319,399,343 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 655 | py | https://www.codewars.com/kata/5536aba6e4609cc6a600003d
import re
def sursurungal(txt):
arr = re.split(r'(\W+)', txt)
res = []
i = 0
while i < len(arr):
if arr[i].isdigit():
n = int(arr[i])
if n in [0,1]:
res.append(f"{arr[i]} {arr[i+2]}")
else:
word = arr[i+2]
word = word[:-1]
if n == 2: res.append(f"{n} bu{word}")
if 3<=n<=9: res.append(f"{n} {word}zo")
if n>=10: res.append(f"{n} ga{word}ga")
i+=3
else:
res.append(arr[i])
i+=1
return "".join(res) | [
"larisaplantation@gmail.com"
] | larisaplantation@gmail.com |
28c5c03bd5a4e73df26417fd60a8fb3f7b6013eb | 2c9904d2f4fb396a4c61885a315dedca2f3a3d99 | /cells.py | d45899b0c7cdb7889457ed4e995cc9ffea63df85 | [
"MIT"
] | permissive | levshaket/bioinf | 6f707ac7b2732bcf25d68b85a6b8c06888118834 | 0c828d05bab604f2d012fd9cb929cb29f2d6c025 | refs/heads/master | 2020-04-17T09:06:01.251975 | 2019-01-18T17:07:24 | 2019-01-18T17:07:24 | 166,444,690 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 4,101 | py | #! python2.7
################## Cell Type and Gene Expression Simulation ##################
import numpy as np
import random
from bioinf import express
from hamming import print_hamming
random.seed()
################## Select Parameters ##################
cells = 100 ; genes = 10000 ; cell_types = 5 ; gene_sets = 25 ; mode = 'uniform'
cell_profile = np.array([ \
['o','o','o','h','h','h','h','l','l','l','o','o','o','o','o','o','o','o','o','o','o','o','o','o','o'],\
['o','o','o','h','h','h','h','l','l','l','l','l','l','o','o','o','o','o','o','o','o','o','o','o','o'],\
['o','o','o','o','o','o','o','o','o','o','o','o','o','o','o','o','o','o','o','o','o','o','o','o','o'],\
['o','o','o','o','o','o','o','o','o','o','o','o','o','o','o','o','o','o','o','o','o','o','o','o','o'],\
['o','o','o','o','o','o','o','o','o','o','o','o','o','o','o','o','o','o','o','o','o','o','o','o','o']])
cell_type_distribution = [20, 20, 20, 20, 20];
gene_set_distribution = [400, 400, 400, 400, 400,\
400, 400, 400, 400, 400,\
400, 400, 400, 400, 400,\
400, 400, 400, 400, 400,\
400, 400, 400, 400, 400]
cell_types_to_sample = np.array([0,1,2,3])
#Randomly assign based on cell type expression level values to each gene.
a = np.zeros((cells, genes),dtype='float')
I,J = a.shape
cell_profile_expanded = np.repeat(np.repeat(cell_profile,cell_type_distribution,axis=0),gene_set_distribution,axis=1)
for i in range(I):
for j in range(J):#consider xrange()
a[i][j] = express(mode,cell_profile_expanded[i][j])
#Sample 4 cell types with replacement from available cell types. Randomly choose a cell(s) from each cell type.
#cell_types_to_sample = np.array(random.sample(4*range(cell_types),4))
types_, frequency = np.unique(cell_types_to_sample, return_counts=True); cells_sampled=[];
cumsum = np.cumsum(cell_type_distribution)
for i in range(len(types_)):
type_, boundary= cell_type_distribution[types_[i]], cumsum[types_[i]]
cells_sampled += list(random.sample(range(type_),frequency[i])+boundary-type_)
b = np.zeros((3,4,genes),dtype='float'); permutations = [[0,1,2,3],[0,3,1,2],[0,1,3,2]]
b[0,:,:] = a[cells_sampled]
b[1,:,:] = b[0,:,:][permutations[1]]
b[2,:,:] = b[0,:,:][permutations[2]]
#Compute 3 permutations of Hamming distance matrix for each pair of cells
c = np.zeros((3,4,4),dtype='float')
K,I,J = c.shape
for k in range(K):
for i in range(I):
for j in range(J):
c[k][i][j] = sum(abs(b[k][i][:]-b[k][j][:]))
#Compute Hamming distance box plots for each of the permutations. Discard permutations that result in negative variables.
print('Cells:%i\nGenes:%i\nExpression:random_%s_value_assigned_to_each_gene\nHamming matrix:'%(cells,genes,mode))
for k in range(K):
H1,H2,H3=c[k][0][1:]
H4,H5=c[k][1][2:]
H6=c[k][2][3]
A=int(0.5*(H1+H2-H4))
B=int(0.5*(H1+H5-H3))
C=int(0.5*(H2+H6-H3))
D=int(0.5*(H5+H6-H4))
E=int(0.5*(H3+H4-H2-H5))
F=int(0.5*(H3+H4-H1-H6))
coordinates = np.array([A,B,C,D,E,F])/(max(A,B,C,D,E,F)/10); delta=min(E,F)/float(max(E,F))
X,Y,U,V = cell_types_to_sample[permutations[k]]
if (A<0 or B<0 or C<0 or D<0 or E<0 or F<0):
print('\tPermutation %i: negative coordinates'%k)
print('\tcoordinates= [%i,%i,%i,%i,%i,%i]'%(A,B,C,D,E,F))
print('\tcell_type_at_vertices= [%i,%i,%i,%i]\n'%(X,Y,U,V))
continue
else:
print('\tPermutation %i:'%k)
print('\tdelta= %f'%delta)
print('\tcoordinates= [%i,%i,%i,%i,%i,%i]'%(A,B,C,D,E,F))
print('\tcell_type_at_vertices= [%i,%i,%i,%i]\n'%(X,Y,U,V))
print_hamming(coordinates)
#Compute completely random Hamming distance matrix
#d = np.zeros((4,4),dtype='int')
#I,J = d.shape
#for i in range(I):
# for j in range(J):
# if j>i:
# d[i][j] = d[j][i] = random.randint(0,10000)
#Sample 4 cells without replacement from total cell population. Determine cell types from sample cell index.
#cells_sampled = random.sample(range(cells),4); cell_types_sampled= []
#for cell_sampled in cells_sampled:
# j = 0; cumsum = 0
# while j < cell_types:
# cumsum += cell_type_distribution[j]
# if cell_sampled < cumsum:
# cell_types_sampled.append(j)
# break
# j+=1
| [
"noreply@github.com"
] | levshaket.noreply@github.com |
8865db146159f578256de4ca7df771ec7049b312 | d2f4eb41c95e35a21c257554efbaf18a557d4f4a | /KneiborsClassfier.py | 9ebdbadd0a59fb28173de4d19d2b21347c5b7885 | [
"Apache-2.0"
] | permissive | madcow2021/Insect_Identification | 1d7fbf5ce4a5d72d4994e5af2078701787eb08b4 | ae9e30c09f47b343664b3cb18e893fedcd84b335 | refs/heads/master | 2022-02-03T22:31:17.108726 | 2019-06-05T01:34:46 | 2019-06-05T01:34:46 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,355 | py | # coding=utf-8
import pandas as pd
# 创建特征列表
column_names = ['P_rect', 'P_extend', 'P_spherical', 'P_leaf', 'P_circle', 'Species']
# column_names = ['P_rect', 'P_extend', 'P_spherical', 'P_leaf', 'P_circle','P_complecate', 'Species']
data = pd.read_csv('data/data.csv', names=column_names)
# print data.shape
# 这个功能快要被抛弃了,分割训练和测试集
from sklearn.cross_validation import train_test_split
X_train, X_test, Y_train, Y_test = train_test_split(data[column_names[0:5]], data[column_names[5]], test_size=0.25,
random_state=33)
# print Y_train.value_counts()
# print Y_test.value_counts()
# 数据整理，但是整形的，需要注意
# from sklearn.preprocessing import StandardScaler
# ss = StandardScaler()
# X_train = ss.fit_transform(X_train)
# X_test = ss.transform(X_test)
from sklearn.neighbors import KNeighborsClassifier
knc = KNeighborsClassifier()
knc.fit(X_train, Y_train)
knc_y_predict = knc.predict(X_test)
from sklearn.metrics import classification_report
print "LR 精确度：" + str(knc.score(X_test, Y_test))
print classification_report(Y_test, knc_y_predict, target_names=[ 'fly','wo','jingui','zhang','zhizhu'])
# 保存训练结果，供后面直接使用
from sklearn.externals import joblib
joblib.dump(knc,'model/knc.model')
| [
"veraposeidon@gmail.com"
] | veraposeidon@gmail.com |
c9720d78ca4b2c9836da119409d84623a2233f3c | c7e8ad53014c244b6e716503b91128caa5a572bf | /catalog/migrations/0004_auto_20200718_1130.py | 0de558fec3be138363d2b612f29641651019708b | [] | no_license | ShimnaA/mylibrary | bd40b2846c900aee60b745cf0a3d48b9a2c72d5c | fa93a524a82d697cabc57405e60729c5fd9cb69d | refs/heads/master | 2022-11-18T23:41:12.180071 | 2020-07-18T09:43:55 | 2020-07-18T09:43:55 | 280,079,687 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 420 | py | # Generated by Django 3.0.8 on 2020-07-18 06:00
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('catalog', '0003_auto_20200717_1525'),
]
operations = [
migrations.AlterModelOptions(
name='bookinstance',
options={'ordering': ['due_back'], 'permissions': (('can_mark_returned', 'Set book as returned'),)},
),
]
| [
"shimnaa.arangil@gmail.com"
] | shimnaa.arangil@gmail.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.