_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 75 19.8k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q249600 | DataAbstract.plot_svd | train | def plot_svd(self, lapack_driver='gesdd', modes=None, key=None, Bck=True,
Lplot='In', cmap=None, vmin=None, vmax=None,
cmap_topos=None, vmin_topos=None, vmax_topos=None,
ntMax=None, nchMax=None, ms=4,
inct=[1,10], incX=[1,5], incm=[1,5],
... | python | {
"resource": ""
} |
q249601 | DataSpectro.plot | train | def plot(self, key=None, invert=None, plotmethod='imshow',
cmap=plt.cm.gray, ms=4, Max=None,
fs=None, dmargin=None, wintit=None,
draw=True, connect=True):
""" Plot the data content in a predefined figure """
dax, KH = _plot.Data_plot(self, key=key, invert=invert, ... | python | {
"resource": ""
} |
q249602 | LOS_PRMin | train | def LOS_PRMin(Ds, dus, kPOut=None, Eps=1.e-12, Test=True):
""" Compute the point on the LOS where the major radius is minimum """
if Test:
assert Ds.ndim in [1,2] and 3 in Ds.shape and Ds.shape==dus.shape
assert kPOut is None or (Ds.ndim==1 and not hasattr(kPOut,'__iter__')) or (Ds.ndim==2 and ... | python | {
"resource": ""
} |
q249603 | LOS_get_sample | train | def LOS_get_sample(D, u, dL, DL=None, dLMode='abs', method='sum', Test=True):
""" Return the sampled line, with the specified method
'linspace': return the N+1 edges, including the first and last point
'sum' : return the N middle of the segments
'simps': return the N+1 egdes, where N has to be even (sc... | python | {
"resource": ""
} |
q249604 | Struct.isInside | train | def isInside(self, pts, In='(X,Y,Z)'):
""" Return an array of booleans indicating whether each point lies
inside the Struct volume
Tests for each point whether it lies inside the Struct object.
The points coordinates can be provided in 2D or 3D
You must specify which coordinate ... | python | {
"resource": ""
} |
q249605 | Struct.get_InsideConvexPoly | train | def get_InsideConvexPoly(self, RelOff=_def.TorRelOff, ZLim='Def',
Spline=True, Splprms=_def.TorSplprms,
NP=_def.TorInsideNP, Plot=False, Test=True):
""" Return a polygon that is a smaller and smoothed approximation of Ves.Poly, useful for excluding the d... | python | {
"resource": ""
} |
q249606 | Struct.get_sampleEdge | train | def get_sampleEdge(self, res, DS=None, resMode='abs', offsetIn=0.):
""" Sample the polygon edges, with resolution res
Sample each segment of the 2D polygon
Sampling can be limited to a subdomain defined by DS
"""
pts, dlr, ind = _comp._Ves_get_sampleEdge(self.Poly, res, DS=DS,
... | python | {
"resource": ""
} |
q249607 | Struct.get_sampleCross | train | def get_sampleCross(self, res, DS=None, resMode='abs', ind=None):
""" Sample, with resolution res, the 2D cross-section
The sampling domain can be limited by DS or ind
"""
args = [self.Poly, self.dgeom['P1Min'][0], self.dgeom['P1Max'][0],
self.dgeom['P2Min'][1], self.dge... | python | {
"resource": ""
} |
q249608 | Struct.get_sampleS | train | def get_sampleS(self, res, DS=None, resMode='abs',
ind=None, offsetIn=0., Out='(X,Y,Z)', Ind=None):
""" Sample, with resolution res, the surface defined by DS or ind
An optionnal offset perpendicular to the surface can be used
(offsetIn>0 => inwards)
Parameters
... | python | {
"resource": ""
} |
q249609 | Struct.get_sampleV | train | def get_sampleV(self, res, DV=None, resMode='abs', ind=None, Out='(X,Y,Z)'):
""" Sample, with resolution res, the volume defined by DV or ind """
args = [self.Poly, self.dgeom['P1Min'][0], self.dgeom['P1Max'][0],
self.dgeom['P2Min'][1], self.dgeom['P2Max'][1], res]
kwdargs = dic... | python | {
"resource": ""
} |
q249610 | Struct.plot | train | def plot(self, lax=None, proj='all', element='PIBsBvV',
dP=None, dI=_def.TorId, dBs=_def.TorBsd, dBv=_def.TorBvd,
dVect=_def.TorVind, dIHor=_def.TorITord, dBsHor=_def.TorBsTord,
dBvHor=_def.TorBvTord, Lim=None, Nstep=_def.TorNTheta,
dLeg=_def.TorLegd, indices=False,
... | python | {
"resource": ""
} |
q249611 | Struct.plot_sino | train | def plot_sino(self, ax=None, Ang=_def.LOSImpAng,
AngUnit=_def.LOSImpAngUnit, Sketch=True, dP=None,
dLeg=_def.TorLegd, draw=True, fs=None, wintit=None,
Test=True):
""" Plot the sinogram of the vessel polygon, by computing its envelopp in a cross-section, can ... | python | {
"resource": ""
} |
q249612 | Config.lStruct | train | def lStruct(self):
""" Return the list of Struct that was used for creation
As tofu objects or SavePath+SaveNames (according to strip status)
"""
lStruct = []
for k in self._dStruct['lorder']:
k0, k1 = k.split('_')
lStruct.append(self._dStruct['dObj'][k0]... | python | {
"resource": ""
} |
q249613 | Config.lStructIn | train | def lStructIn(self):
""" Return the list of StructIn contained in self.lStruct
As tofu objects or SavePath+SaveNames (according to strip status)
"""
lStruct = []
for k in self._dStruct['lorder']:
k0, k1 = k.split('_')
if type(self._dStruct['dObj'][k0][k1]... | python | {
"resource": ""
} |
q249614 | Config.get_summary | train | def get_summary(self, verb=False, max_columns=100, width=1000):
""" Summary description of the object content as a pandas DataFrame """
# Make sure the data is accessible
msg = "The data is not accessible because self.strip(2) was used !"
assert self._dstrip['strip']<2, msg
# Bu... | python | {
"resource": ""
} |
q249615 | Config.isInside | train | def isInside(self, pts, In='(X,Y,Z)', log='any'):
""" Return a 2D array of bool
Equivalent to applying isInside to each Struct
Check self.lStruct[0].isInside? for details
Arg log determines how Struct with multiple Limits are treated
- 'all' : True only if pts belong to all... | python | {
"resource": ""
} |
q249616 | Rays.get_sample | train | def get_sample(self, res, resMode='abs', DL=None, method='sum', ind=None,
compact=False):
""" Return a linear sampling of the LOS
The LOS is sampled into a series a points and segments lengths
The resolution (segments length) is <= res
The sampling can be done accordin... | python | {
"resource": ""
} |
q249617 | Rays.calc_kInkOut_IsoFlux | train | def calc_kInkOut_IsoFlux(self, lPoly, lVIn=None, Lim=None,
kInOut=True):
""" Calculate the intersection points of each ray with each isoflux
The isofluxes are provided as a list of 2D closed polygons
The intersections are the inward and outward intersections
... | python | {
"resource": ""
} |
q249618 | Rays.get_touch_dict | train | def get_touch_dict(self, ind=None, out=bool):
""" Get a dictionnary of Cls_Name struct with indices of Rays touching
Only includes Struct object with compute = True
(as returned by self.lStruct__computeInOut_computeInOut)
Also return the associated colors
If in is not None, ... | python | {
"resource": ""
} |
q249619 | merge_urls_data_to | train | def merge_urls_data_to(to, food={}):
"""Merge urls data"""
if not to:
to.update(food)
for url, data in food.items():
if url not in to:
to[url] = data
else:
to[url] = to[url].merge_with(data) | python | {
"resource": ""
} |
q249620 | merge_requests_data_to | train | def merge_requests_data_to(to, food={}):
"""Merge a small analyzed result to a big one, this function will modify the
original ``to``"""
if not to:
to.update(food)
to['requests_counter']['normal'] += food['requests_counter']['normal']
to['requests_counter']['slow'] += food['requests_counte... | python | {
"resource": ""
} |
q249621 | format_data | train | def format_data(raw_data, limit_per_url_group=LIMIT_PER_URL_GROUP, limit_url_groups=LIMIT_URL_GROUPS):
"""Fomat data from LogAnalyzer for render purpose"""
data = copy.deepcopy(raw_data)
for k, v in list(data['data_details'].items()):
# Only reserve first ``limit_per_url_group`` items
v['url... | python | {
"resource": ""
} |
q249622 | URLClassifier.classify | train | def classify(self, url_path):
"""Classify an url"""
for dict_api_url in self.user_defined_rules:
api_url = dict_api_url['str']
re_api_url = dict_api_url['re']
if re_api_url.match(url_path[1:]):
return api_url
return self.RE_SIMPLIFY_URL.sub(r'... | python | {
"resource": ""
} |
q249623 | ValidationResult.annotate_rule_violation | train | def annotate_rule_violation(self, rule: ValidationRule) -> None:
"""
Takes note of a rule validation failure by collecting its error message.
:param rule: Rule that failed validation.
:type rule: ValidationRule
:return: None
"""
if self.errors.get(rule.label) is ... | python | {
"resource": ""
} |
q249624 | get_PolyFromPolyFileObj | train | def get_PolyFromPolyFileObj(PolyFileObj, SavePathInp=None, units='m', comments='#', skiprows=0, shape0=2):
""" Return a polygon as a np.ndarray, extracted from a txt file or from a ToFu object, with appropriate units
Useful for :meth:`tofu.plugins.AUG.Ves._create()`
Parameters
----------
PolyFileO... | python | {
"resource": ""
} |
q249625 | CheckSameObj | train | def CheckSameObj(obj0, obj1, LFields=None):
""" Check if two variables are the same instance of a ToFu class
Checks a list of attributes, provided by LField
Parameters
----------
obj0 : tofu object
A variable refering to a ToFu object of any class
obj1 : tofu object
A... | python | {
"resource": ""
} |
q249626 | Save_Generic | train | def Save_Generic(obj, SaveName=None, Path='./',
Mode='npz', compressed=False, Print=True):
""" Save a ToFu object under file name SaveName, in folder Path
ToFu provides built-in saving and loading functions for ToFu objects.
There is now only one saving mode:
- 'npz': saves a dict ... | python | {
"resource": ""
} |
q249627 | Open | train | def Open(pathfileext=None,
shot=None, t=None, Dt=None, Mesh=None, Deg=None, Deriv=None,
Sep=True, Pos=True, OutPath=None, ReplacePath=None, Ves=None,
out='full', Verb=False, Print=True):
""" Open a ToFu object saved file
This generic open function identifies the required loading rout... | python | {
"resource": ""
} |
q249628 | ID.set_LObj | train | def set_LObj(self,LObj=None):
""" Set the LObj attribute, storing objects the instance depends on
For example:
A Detect object depends on a vessel and some apertures
That link between should be stored somewhere (for saving/loading).
LObj does this: it stores the ID (as dict) of ... | python | {
"resource": ""
} |
q249629 | ID.set_USRdict | train | def set_USRdict(self,USRdict={}):
""" Set the USRdict, containing user-defined info about the instance
Useful for arbitrary info (e.g.: manufacturing date, material...)
Parameters
----------
USRdict : dict
A user-defined dictionary containing info about the instan... | python | {
"resource": ""
} |
q249630 | create_config | train | def create_config(case=None, Exp='Dummy', Type='Tor',
Lim=None, Bump_posextent=[np.pi/4., np.pi/4],
R=2.4, r=1., elong=0., Dshape=0.,
divlow=True, divup=True, nP=200,
out='object', SavePath='./'):
""" Create easily a tofu.geom.Config object
... | python | {
"resource": ""
} |
q249631 | analyze_log | train | def analyze_log(fp, configs, url_rules):
"""Analyze log file"""
url_classifier = URLClassifier(url_rules)
analyzer = LogAnalyzer(url_classifier=url_classifier, min_msecs=configs.min_msecs)
for line in fp:
analyzer.analyze_line(line)
return analyzer.get_data() | python | {
"resource": ""
} |
q249632 | _spectrogram_scipy_fourier | train | def _spectrogram_scipy_fourier(data, fs, nt, nch, fmin=None,
window=('tukey', 0.25), deg=False,
nperseg=None, noverlap=None,
detrend='linear', stft=False,
boundary='constant', padded=True, warn=Tr... | python | {
"resource": ""
} |
q249633 | filter_svd | train | def filter_svd(data, lapack_driver='gesdd', modes=[]):
""" Return the svd-filtered signal using only the selected mode
Provide the indices of the modes desired
"""
# Check input
modes = np.asarray(modes,dtype=int)
assert modes.ndim==1
assert modes.size>=1, "No modes selected !"
u, s, ... | python | {
"resource": ""
} |
q249634 | HTMLRender.render_requests_data_to_html | train | def render_requests_data_to_html(self, data, file_name, context={}):
"""Render to HTML file"""
file_path = os.path.join(self.html_dir, file_name)
logger.info('Rendering HTML file %s...' % file_path)
data = format_data(data)
data.update(context)
data.update(domain=self.dom... | python | {
"resource": ""
} |
q249635 | get_figuresize | train | def get_figuresize(fs, fsdef=(12,6),
orient='landscape', method='xrandr'):
""" Generic function to return figure size in inches
Useful for str-based flags such as:
- 'a4' : use orient='portrait' or 'landscape'
- 'full': to get screen size
use meth... | python | {
"resource": ""
} |
q249636 | _set_arrayorder | train | def _set_arrayorder(obj, arrayorder='C'):
""" Set the memory order of all np.ndarrays in a tofu object """
msg = "Arg arrayorder must be in ['C','F']"
assert arrayorder in ['C','F'], msg
d = obj.to_dict(strip=-1)
account = {'Success':[], 'Failed':[]}
for k, v in d.items():
if type(v) is... | python | {
"resource": ""
} |
q249637 | save | train | def save(obj, path=None, name=None, sep=_sep, deep=False, mode='npz',
strip=None, compressed=False, verb=True, return_pfe=False):
""" Save the ToFu object
ToFu provides built-in saving and loading functions for ToFu objects.
Specifying saving path ad name is optional (defaults recommended)
The... | python | {
"resource": ""
} |
q249638 | load | train | def load(name, path=None, strip=None, verb=True):
""" Load a tofu object file
Can load from .npz or .txt files
In future versions, will also load from .mat
The file must have been saved with tofu (i.e.: must be tofu-formatted)
The associated tofu object will be created and returned
Pa... | python | {
"resource": ""
} |
q249639 | ToFuObjectBase.to_dict | train | def to_dict(self, strip=None, sep=_sep, deep='ref'):
""" Return a flat dict view of the object's attributes
Useful for:
* displaying all attributes
* saving to file
* exchaning data with non-tofu libraries
Parameters
----------
strip : in... | python | {
"resource": ""
} |
q249640 | ToFuObjectBase.from_dict | train | def from_dict(self, fd, sep=_sep, strip=None):
""" Populate the instances attributes using an input dict
The input dict must be properly formatted
In practice it should be the return output of a similar class to_dict()
Parameters
----------
fd : dict
The ... | python | {
"resource": ""
} |
q249641 | ToFuObjectBase.copy | train | def copy(self, strip=None, deep='ref'):
""" Return another instance of the object, with the same attributes
If deep=True, all attributes themselves are also copies
"""
dd = self.to_dict(strip=strip, deep=deep)
return self.__class__(fromdict=dd) | python | {
"resource": ""
} |
q249642 | ID.set_lObj | train | def set_lObj(self, lObj=None):
""" Set the lObj attribute, storing objects the instance depends on
For example:
A Detect object depends on a vessel and some apertures
That link between should be stored somewhere (for saving/loading).
lObj does this: it stores the ID (as dict) of... | python | {
"resource": ""
} |
q249643 | Tailer.seek_line_forward | train | def seek_line_forward(self):
"""\
Searches forward from the current file position for a line terminator
and seeks to the charachter after it.
"""
pos = start_pos = self.file.tell()
bytes_read, read_str = self.read(self.read_size)
start = 0
if bytes_read ... | python | {
"resource": ""
} |
q249644 | Tailer.seek_line | train | def seek_line(self):
"""\
Searches backwards from the current file position for a line terminator
and seeks to the charachter after it.
"""
pos = end_pos = self.file.tell()
read_size = self.read_size
if pos > read_size:
pos -= read_size
else:
... | python | {
"resource": ""
} |
q249645 | Tailer.tail | train | def tail(self, lines=10):
"""\
Return the last lines of the file.
"""
self.seek_end()
end_pos = self.file.tell()
for i in range(lines):
if not self.seek_line():
break
data = self.file.read(end_pos - self.file.tell() - 1)
if da... | python | {
"resource": ""
} |
q249646 | Tailer.head | train | def head(self, lines=10):
"""\
Return the top lines of the file.
"""
self.seek(0)
for i in range(lines):
if not self.seek_line_forward():
break
end_pos = self.file.tell()
self.seek(0)
data = self.file.read(end_pos... | python | {
"resource": ""
} |
q249647 | get_html_tree | train | def get_html_tree(filename_url_or_filelike):
"""From some file path, input stream, or URL, construct and return
an HTML tree.
"""
try:
handler = (
HTTPSHandler
if filename_url_or_filelike.lower().startswith('https')
else HTTPHandler
)
... | python | {
"resource": ""
} |
q249648 | calc_across_paths_textnodes | train | def calc_across_paths_textnodes(paths_nodes, dbg=False):
"""Given a list of parent paths tupled with children textnodes, plus
initialized feature values, we calculate the total and average string
length of the parent's children textnodes.
"""
# for (path, [textnodes],
# num. of... | python | {
"resource": ""
} |
q249649 | extract | train | def extract(filename_url_or_filelike):
"""A more precise algorithm over the original eatiht algorithm
"""
pars_tnodes = get_parent_xpaths_and_textnodes(filename_url_or_filelike)
#[iterable, cardinality, ttl across iterable, avg across iterable.])
calc_across_paths_textnodes(pars_tnodes)
... | python | {
"resource": ""
} |
q249650 | extract | train | def extract(filename_url_filelike_or_htmlstring):
"""An "improved" algorithm over the original eatiht algorithm
"""
html_tree = get_html_tree(filename_url_filelike_or_htmlstring)
subtrees = get_textnode_subtrees(html_tree)
#[iterable, cardinality, ttl across iterable, avg across iterable.])
... | python | {
"resource": ""
} |
q249651 | TextNodeSubTree.__learn_oneself | train | def __learn_oneself(self):
"""calculate cardinality, total and average string length"""
if not self.__parent_path or not self.__text_nodes:
raise Exception("This error occurred because the step constructor\
had insufficient textnodes or it had empty string\
... | python | {
"resource": ""
} |
q249652 | TextNodeTree.__make_tree | train | def __make_tree(self):
"""Build a tree using lxml.html.builder and our subtrees"""
# create div with "container" class
div = E.DIV(E.CLASS("container"))
# append header with title
div.append(E.H2(self.__title))
# next, iterate through subtrees appending each t... | python | {
"resource": ""
} |
q249653 | TextNodeTree.get_html | train | def get_html(self):
"""Generates if need be and returns a simpler html document with text"""
if self.__htmltree is not None:
return self.__htmltree
else:
self.__make_tree()
return self.__htmltree | python | {
"resource": ""
} |
q249654 | TextNodeTree.get_html_string | train | def get_html_string(self):
"""Generates if need be and returns a simpler html string with
extracted text"""
if self.__htmltree is not None:
return htmltostring(self.__htmltree)
else:
self.__make_tree()
return htmltostring(self.__htmltree) | python | {
"resource": ""
} |
q249655 | TextNodeTree.get_text | train | def get_text(self):
"""Return all joined text from each subtree"""
if self.__fulltext:
return self.__fulltext
else:
self.__fulltext = "\n\n".join(text.get_text()
for text in self.__subtrees)
return self.__fullte... | python | {
"resource": ""
} |
q249656 | TextNodeTree.bootstrapify | train | def bootstrapify(self):
"""Add bootstrap cdn to headers of html"""
if self.__htmltree is None:
#raise Exception("HtmlTree has not been made yet")
self.__make_tree()
# add bootstrap cdn to head
self.__htmltree.find('head').append(
E.LINK(rel="s... | python | {
"resource": ""
} |
q249657 | rar3_type | train | def rar3_type(btype):
"""RAR3 type code as string."""
if btype < rf.RAR_BLOCK_MARK or btype > rf.RAR_BLOCK_ENDARC:
return "*UNKNOWN*"
return block_strs[btype - rf.RAR_BLOCK_MARK] | python | {
"resource": ""
} |
q249658 | xprint | train | def xprint(m, *args):
"""Print string to stdout.
Format unicode safely.
"""
if sys.hexversion < 0x3000000:
m = m.decode('utf8')
if args:
m = m % args
if sys.hexversion < 0x3000000:
m = m.encode('utf8')
sys.stdout.write(m)
sys.stdout.write('\n') | python | {
"resource": ""
} |
q249659 | render_flags | train | def render_flags(flags, bit_list):
"""Show bit names.
"""
res = []
known = 0
for bit in bit_list:
known = known | bit[0]
if flags & bit[0]:
res.append(bit[1])
unknown = flags & ~known
n = 0
while unknown:
if unknown & 1:
res.append("UNK_%04... | python | {
"resource": ""
} |
q249660 | get_file_flags | train | def get_file_flags(flags):
"""Show flag names and handle dict size.
"""
res = render_flags(flags & ~rf.RAR_FILE_DICTMASK, file_bits)
xf = (flags & rf.RAR_FILE_DICTMASK) >> 5
res += "," + file_parms[xf]
return res | python | {
"resource": ""
} |
q249661 | show_item_v3 | train | def show_item_v3(h):
"""Show any RAR3 record.
"""
st = rar3_type(h.type)
xprint("%s: hdrlen=%d datlen=%d", st, h.header_size, h.add_size)
if h.type in (rf.RAR_BLOCK_FILE, rf.RAR_BLOCK_SUB):
if h.host_os == rf.RAR_OS_UNIX:
s_mode = "0%o" % h.mode
else:
s_mode =... | python | {
"resource": ""
} |
q249662 | check_crc | train | def check_crc(f, inf, desc):
"""Compare result crc to expected value.
"""
exp = inf._md_expect
if exp is None:
return
ucrc = f._md_context.digest()
if ucrc != exp:
print('crc error - %s - exp=%r got=%r' % (desc, exp, ucrc)) | python | {
"resource": ""
} |
q249663 | load_vint | train | def load_vint(buf, pos):
"""Load variable-size int."""
limit = min(pos + 11, len(buf))
res = ofs = 0
while pos < limit:
b = _byte_code(buf[pos])
res += ((b & 0x7F) << ofs)
pos += 1
ofs += 7
if b < 0x80:
return res, pos
raise BadRarFile('cannot load... | python | {
"resource": ""
} |
q249664 | load_byte | train | def load_byte(buf, pos):
"""Load single byte"""
end = pos + 1
if end > len(buf):
raise BadRarFile('cannot load byte')
return S_BYTE.unpack_from(buf, pos)[0], end | python | {
"resource": ""
} |
q249665 | load_le32 | train | def load_le32(buf, pos):
"""Load little-endian 32-bit integer"""
end = pos + 4
if end > len(buf):
raise BadRarFile('cannot load le32')
return S_LONG.unpack_from(buf, pos)[0], pos + 4 | python | {
"resource": ""
} |
q249666 | load_bytes | train | def load_bytes(buf, num, pos):
"""Load sequence of bytes"""
end = pos + num
if end > len(buf):
raise BadRarFile('cannot load bytes')
return buf[pos : end], end | python | {
"resource": ""
} |
q249667 | load_vstr | train | def load_vstr(buf, pos):
"""Load bytes prefixed by vint length"""
slen, pos = load_vint(buf, pos)
return load_bytes(buf, slen, pos) | python | {
"resource": ""
} |
q249668 | load_dostime | train | def load_dostime(buf, pos):
"""Load LE32 dos timestamp"""
stamp, pos = load_le32(buf, pos)
tup = parse_dos_time(stamp)
return to_datetime(tup), pos | python | {
"resource": ""
} |
q249669 | load_unixtime | train | def load_unixtime(buf, pos):
"""Load LE32 unix timestamp"""
secs, pos = load_le32(buf, pos)
dt = datetime.fromtimestamp(secs, UTC)
return dt, pos | python | {
"resource": ""
} |
q249670 | load_windowstime | train | def load_windowstime(buf, pos):
"""Load LE64 windows timestamp"""
# unix epoch (1970) in seconds from windows epoch (1601)
unix_epoch = 11644473600
val1, pos = load_le32(buf, pos)
val2, pos = load_le32(buf, pos)
secs, n1secs = divmod((val2 << 32) | val1, 10000000)
dt = datetime.fromtimestamp... | python | {
"resource": ""
} |
q249671 | is_filelike | train | def is_filelike(obj):
"""Filename or file object?
"""
if isinstance(obj, (bytes, unicode)):
return False
res = True
for a in ('read', 'tell', 'seek'):
res = res and hasattr(obj, a)
if not res:
raise ValueError("Invalid object passed as file")
return True | python | {
"resource": ""
} |
q249672 | rar3_s2k | train | def rar3_s2k(psw, salt):
"""String-to-key hash for RAR3.
"""
if not isinstance(psw, unicode):
psw = psw.decode('utf8')
seed = bytearray(psw.encode('utf-16le') + salt)
h = Rar3Sha1(rarbug=True)
iv = EMPTY
for i in range(16):
for j in range(0x4000):
cnt = S_LONG.pac... | python | {
"resource": ""
} |
q249673 | rar3_decompress | train | def rar3_decompress(vers, meth, data, declen=0, flags=0, crc=0, psw=None, salt=None):
"""Decompress blob of compressed data.
Used for data with non-standard header - eg. comments.
"""
# already uncompressed?
if meth == RAR_M0 and (flags & RAR_FILE_PASSWORD) == 0:
return data
# take onl... | python | {
"resource": ""
} |
q249674 | to_datetime | train | def to_datetime(t):
"""Convert 6-part time tuple into datetime object.
"""
if t is None:
return None
# extract values
year, mon, day, h, m, s = t
# assume the values are valid
try:
return datetime(year, mon, day, h, m, s)
except ValueError:
pass
# sanitize ... | python | {
"resource": ""
} |
q249675 | parse_dos_time | train | def parse_dos_time(stamp):
"""Parse standard 32-bit DOS timestamp.
"""
sec, stamp = stamp & 0x1F, stamp >> 5
mn, stamp = stamp & 0x3F, stamp >> 6
hr, stamp = stamp & 0x1F, stamp >> 5
day, stamp = stamp & 0x1F, stamp >> 5
mon, stamp = stamp & 0x0F, stamp >> 4
yr = (stamp & 0x7F) + 1980
... | python | {
"resource": ""
} |
q249676 | custom_popen | train | def custom_popen(cmd):
"""Disconnect cmd from parent fds, read only from stdout.
"""
# needed for py2exe
creationflags = 0
if sys.platform == 'win32':
creationflags = 0x08000000 # CREATE_NO_WINDOW
# run command
try:
p = Popen(cmd, bufsize=0, stdout=PIPE, stdin=PIPE, stderr... | python | {
"resource": ""
} |
q249677 | custom_check | train | def custom_check(cmd, ignore_retcode=False):
"""Run command, collect output, raise error if needed.
"""
p = custom_popen(cmd)
out, _ = p.communicate()
if p.returncode and not ignore_retcode:
raise RarExecError("Check-run failed")
return out | python | {
"resource": ""
} |
q249678 | check_returncode | train | def check_returncode(p, out):
"""Raise exception according to unrar exit code.
"""
code = p.returncode
if code == 0:
return
# map return code to exception class, codes from rar.txt
errmap = [None,
RarWarning, RarFatalError, RarCRCError, RarLockedArchiveError, # 1..4
... | python | {
"resource": ""
} |
q249679 | membuf_tempfile | train | def membuf_tempfile(memfile):
"""Write in-memory file object to real file."""
memfile.seek(0, 0)
tmpfd, tmpname = mkstemp(suffix='.rar')
tmpf = os.fdopen(tmpfd, "wb")
try:
while True:
buf = memfile.read(BSIZE)
if not buf:
break
tmpf.write... | python | {
"resource": ""
} |
q249680 | RarInfo.isdir | train | def isdir(self):
"""Returns True if entry is a directory.
"""
if self.type == RAR_BLOCK_FILE:
return (self.flags & RAR_FILE_DIRECTORY) == RAR_FILE_DIRECTORY
return False | python | {
"resource": ""
} |
q249681 | RarFile.setpassword | train | def setpassword(self, password):
"""Sets the password to use when extracting.
"""
self._password = password
if self._file_parser:
if self._file_parser.has_header_encryption():
self._file_parser = None
if not self._file_parser:
self._parse()... | python | {
"resource": ""
} |
q249682 | RarFile.read | train | def read(self, fname, psw=None):
"""Return uncompressed data for archive entry.
For longer files using :meth:`RarFile.open` may be better idea.
Parameters:
fname
filename or RarInfo instance
psw
password to use for extracting.
""... | python | {
"resource": ""
} |
q249683 | RarFile.extract | train | def extract(self, member, path=None, pwd=None):
"""Extract single file into current directory.
Parameters:
member
filename or :class:`RarInfo` instance
path
optional destination path
pwd
optional password to use
... | python | {
"resource": ""
} |
q249684 | RarFile.extractall | train | def extractall(self, path=None, members=None, pwd=None):
"""Extract all files into current directory.
Parameters:
path
optional destination path
members
optional filename or :class:`RarInfo` instance list to extract
pwd
... | python | {
"resource": ""
} |
q249685 | CommonParser.has_header_encryption | train | def has_header_encryption(self):
"""Returns True if headers are encrypted
"""
if self._hdrenc_main:
return True
if self._main:
if self._main.flags & RAR_MAIN_PASSWORD:
return True
return False | python | {
"resource": ""
} |
q249686 | CommonParser.getinfo | train | def getinfo(self, member):
"""Return RarInfo for filename
"""
if isinstance(member, RarInfo):
fname = member.filename
else:
fname = member
# accept both ways here
if PATH_SEP == '/':
fname2 = fname.replace("\\", "/")
else:
... | python | {
"resource": ""
} |
q249687 | CommonParser.parse | train | def parse(self):
"""Process file."""
self._fd = None
try:
self._parse_real()
finally:
if self._fd:
self._fd.close()
self._fd = None | python | {
"resource": ""
} |
q249688 | CommonParser.open | train | def open(self, inf, psw):
"""Return stream object for file data."""
if inf.file_redir:
# cannot leave to unrar as it expects copied file to exist
if inf.file_redir[0] in (RAR5_XREDIR_FILE_COPY, RAR5_XREDIR_HARD_LINK):
inf = self.getinfo(inf.file_redir[2])
... | python | {
"resource": ""
} |
q249689 | UnicodeFilename.enc_byte | train | def enc_byte(self):
"""Copy encoded byte."""
try:
c = self.encdata[self.encpos]
self.encpos += 1
return c
except IndexError:
self.failed = 1
return 0 | python | {
"resource": ""
} |
q249690 | UnicodeFilename.std_byte | train | def std_byte(self):
"""Copy byte from 8-bit representation."""
try:
return self.std_name[self.pos]
except IndexError:
self.failed = 1
return ord('?') | python | {
"resource": ""
} |
q249691 | UnicodeFilename.put | train | def put(self, lo, hi):
"""Copy 16-bit value to result."""
self.buf.append(lo)
self.buf.append(hi)
self.pos += 1 | python | {
"resource": ""
} |
q249692 | UnicodeFilename.decode | train | def decode(self):
"""Decompress compressed UTF16 value."""
hi = self.enc_byte()
flagbits = 0
while self.encpos < len(self.encdata):
if flagbits == 0:
flags = self.enc_byte()
flagbits = 8
flagbits -= 2
t = (flags >> flagb... | python | {
"resource": ""
} |
q249693 | RarExtFile.read | train | def read(self, cnt=None):
"""Read all or specified amount of data from archive entry."""
# sanitize cnt
if cnt is None or cnt < 0:
cnt = self._remain
elif cnt > self._remain:
cnt = self._remain
if cnt == 0:
return EMPTY
# actual read
... | python | {
"resource": ""
} |
q249694 | RarExtFile._check | train | def _check(self):
"""Check final CRC."""
final = self._md_context.digest()
exp = self._inf._md_expect
if exp is None:
return
if final is None:
return
if self._returncode:
check_returncode(self, '')
if self._remain != 0:
... | python | {
"resource": ""
} |
q249695 | RarExtFile.seek | train | def seek(self, ofs, whence=0):
"""Seek in data.
On uncompressed files, the seeking works by actual
seeks so it's fast. On compresses files its slow
- forward seeking happends by reading ahead,
backwards by re-opening and decompressing from the start.
"""
# disa... | python | {
"resource": ""
} |
q249696 | RarExtFile._skip | train | def _skip(self, cnt):
"""Read and discard data"""
while cnt > 0:
if cnt > 8192:
buf = self.read(8192)
else:
buf = self.read(cnt)
if not buf:
break
cnt -= len(buf) | python | {
"resource": ""
} |
q249697 | PipeReader._read | train | def _read(self, cnt):
"""Read from pipe."""
# normal read is usually enough
data = self._fd.read(cnt)
if len(data) == cnt or not data:
return data
# short read, try looping
buf = [data]
cnt -= len(data)
while cnt > 0:
data = self.... | python | {
"resource": ""
} |
q249698 | DirectReader._skip | train | def _skip(self, cnt):
"""RAR Seek, skipping through rar files to get to correct position
"""
while cnt > 0:
# next vol needed?
if self._cur_avail == 0:
if not self._open_next():
break
# fd is in read pos, do the read
... | python | {
"resource": ""
} |
q249699 | DirectReader._read | train | def _read(self, cnt):
"""Read from potentially multi-volume archive."""
buf = []
while cnt > 0:
# next vol needed?
if self._cur_avail == 0:
if not self._open_next():
break
# fd is in read pos, do the read
if cn... | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.