signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def print_result(filt, full=None): | print('<STR_LIT>' % filt.base.size)<EOL>print('<STR_LIT>')<EOL>if full: <EOL><INDENT>if full[<NUM_LIT:4>] == <NUM_LIT:0>: <EOL><INDENT>print('<STR_LIT>' % full[<NUM_LIT:1>])<EOL><DEDENT>else: <EOL><INDENT>r = <NUM_LIT:1>/full[<NUM_LIT:1>]<EOL>print('<STR_LIT>' % r)<EOL><DEDENT>spacing = full[<NUM_LIT:0>][<NUM_LIT:0>... | r"""Print best filter information.
Parameters
----------
- filt, full as returned from fdesign.design with full_output=True | f13208:m4 |
def _call_qc_transform_pairs(n, ispacing, ishift, fI, fC, r, r_def, reim): | print('<STR_LIT>')<EOL>print('<STR_LIT>' +<EOL>'<STR_LIT>')<EOL>print('<STR_LIT>' +<EOL>'<STR_LIT>')<EOL>minspace = np.arange(*ispacing).min()<EOL>maxspace = np.arange(*ispacing).max()<EOL>minshift = np.arange(*ishift).min()<EOL>maxshift = np.arange(*ishift).max()<EOL>maxbase = np.exp(maxspace*(n//<NUM_LIT:2>) + maxshi... | r"""QC the input transform pairs. | f13208:m5 |
def _plot_transform_pairs(fCI, r, k, axes, tit): | <EOL>plt.sca(axes[<NUM_LIT:0>])<EOL>plt.title('<STR_LIT:|>' + tit + '<STR_LIT>')<EOL>for f in fCI:<EOL><INDENT>if f.name == '<STR_LIT>':<EOL><INDENT>lhs = f.lhs(k)<EOL>plt.loglog(k, np.abs(lhs[<NUM_LIT:0>]), lw=<NUM_LIT:2>, label='<STR_LIT>')<EOL>plt.loglog(k, np.abs(lhs[<NUM_LIT:1>]), lw=<NUM_LIT:2>, label='<STR_LIT>'... | r"""Plot the input transform pairs. | f13208:m6 |
def _plot_inversion(f, rhs, r, k, imin, spacing, shift, cvar): | <EOL>if not plt:<EOL><INDENT>print(plt_msg)<EOL>return<EOL><DEDENT>plt.figure("<STR_LIT>"+f.name, figsize=(<NUM_LIT>, <NUM_LIT:4>))<EOL>plt.subplots_adjust(wspace=<NUM_LIT>, bottom=<NUM_LIT>)<EOL>plt.clf()<EOL>tk = np.logspace(np.log10(k.min()), np.log10(k.max()), r.size)<EOL>plt.suptitle(f.name+'<STR_LIT>'+str(spacing... | r"""QC the resulting filter. | f13208:m7 |
def j0_1(a=<NUM_LIT:1>): | def lhs(x):<EOL><INDENT>return x*np.exp(-a*x**<NUM_LIT:2>)<EOL><DEDENT>def rhs(b):<EOL><INDENT>return np.exp(-b**<NUM_LIT:2>/(<NUM_LIT:4>*a))/(<NUM_LIT:2>*a)<EOL><DEDENT>return Ghosh('<STR_LIT>', lhs, rhs)<EOL> | r"""Hankel transform pair J0_1 ([Ande75]_). | f13208:m8 |
def j0_2(a=<NUM_LIT:1>): | def lhs(x):<EOL><INDENT>return np.exp(-a*x)<EOL><DEDENT>def rhs(b):<EOL><INDENT>return <NUM_LIT:1>/np.sqrt(b**<NUM_LIT:2> + a**<NUM_LIT:2>)<EOL><DEDENT>return Ghosh('<STR_LIT>', lhs, rhs)<EOL> | r"""Hankel transform pair J0_2 ([Ande75]_). | f13208:m9 |
def j0_3(a=<NUM_LIT:1>): | def lhs(x):<EOL><INDENT>return x*np.exp(-a*x)<EOL><DEDENT>def rhs(b):<EOL><INDENT>return a/(b**<NUM_LIT:2> + a**<NUM_LIT:2>)**<NUM_LIT><EOL><DEDENT>return Ghosh('<STR_LIT>', lhs, rhs)<EOL> | r"""Hankel transform pair J0_3 ([GuSi97]_). | f13208:m10 |
def j0_4(f=<NUM_LIT:1>, rho=<NUM_LIT>, z=<NUM_LIT:50>): | gam = np.sqrt(<NUM_LIT>*np.pi*mu_0*f/rho)<EOL>def lhs(x):<EOL><INDENT>beta = np.sqrt(x**<NUM_LIT:2> + gam**<NUM_LIT:2>)<EOL>return x*np.exp(-beta*np.abs(z))/beta<EOL><DEDENT>def rhs(b):<EOL><INDENT>R = np.sqrt(b**<NUM_LIT:2> + z**<NUM_LIT:2>)<EOL>return np.exp(-gam*R)/R<EOL><DEDENT>return Ghosh('<STR_LIT>', lhs, rhs)<E... | r"""Hankel transform pair J0_4 ([ChCo82]_).
Parameters
----------
f : float
Frequency (Hz)
rho : float
Resistivity (Ohm.m)
z : float
Vertical distance between source and receiver (m) | f13208:m11 |
def j0_5(f=<NUM_LIT:1>, rho=<NUM_LIT>, z=<NUM_LIT:50>): | gam = np.sqrt(<NUM_LIT>*np.pi*mu_0*f/rho)<EOL>def lhs(x):<EOL><INDENT>beta = np.sqrt(x**<NUM_LIT:2> + gam**<NUM_LIT:2>)<EOL>return x*np.exp(-beta*np.abs(z))<EOL><DEDENT>def rhs(b):<EOL><INDENT>R = np.sqrt(b**<NUM_LIT:2> + z**<NUM_LIT:2>)<EOL>return np.abs(z)*(gam*R + <NUM_LIT:1>)*np.exp(-gam*R)/R**<NUM_LIT:3><EOL><DEDE... | r"""Hankel transform pair J0_5 ([ChCo82]_).
Parameters
----------
f : float
Frequency (Hz)
rho : float
Resistivity (Ohm.m)
z : float
Vertical distance between source and receiver (m) | f13208:m12 |
def j1_1(a=<NUM_LIT:1>): | def lhs(x):<EOL><INDENT>return x**<NUM_LIT:2>*np.exp(-a*x**<NUM_LIT:2>)<EOL><DEDENT>def rhs(b):<EOL><INDENT>return b/(<NUM_LIT:4>*a**<NUM_LIT:2>)*np.exp(-b**<NUM_LIT:2>/(<NUM_LIT:4>*a))<EOL><DEDENT>return Ghosh('<STR_LIT>', lhs, rhs)<EOL> | r"""Hankel transform pair J1_1 ([Ande75]_). | f13208:m13 |
def j1_2(a=<NUM_LIT:1>): | def lhs(x):<EOL><INDENT>return np.exp(-a*x)<EOL><DEDENT>def rhs(b):<EOL><INDENT>return (np.sqrt(b**<NUM_LIT:2> + a**<NUM_LIT:2>) - a)/(b*np.sqrt(b**<NUM_LIT:2> + a**<NUM_LIT:2>))<EOL><DEDENT>return Ghosh('<STR_LIT>', lhs, rhs)<EOL> | r"""Hankel transform pair J1_2 ([Ande75]_). | f13208:m14 |
def j1_3(a=<NUM_LIT:1>): | def lhs(x):<EOL><INDENT>return x*np.exp(-a*x)<EOL><DEDENT>def rhs(b):<EOL><INDENT>return b/(b**<NUM_LIT:2> + a**<NUM_LIT:2>)**<NUM_LIT><EOL><DEDENT>return Ghosh('<STR_LIT>', lhs, rhs)<EOL> | r"""Hankel transform pair J1_3 ([Ande75]_). | f13208:m15 |
def j1_4(f=<NUM_LIT:1>, rho=<NUM_LIT>, z=<NUM_LIT:50>): | gam = np.sqrt(<NUM_LIT>*np.pi*mu_0*f/rho)<EOL>def lhs(x):<EOL><INDENT>beta = np.sqrt(x**<NUM_LIT:2> + gam**<NUM_LIT:2>)<EOL>return x**<NUM_LIT:2>*np.exp(-beta*np.abs(z))/beta<EOL><DEDENT>def rhs(b):<EOL><INDENT>R = np.sqrt(b**<NUM_LIT:2> + z**<NUM_LIT:2>)<EOL>return b*(gam*R + <NUM_LIT:1>)*np.exp(-gam*R)/R**<NUM_LIT:3>... | r"""Hankel transform pair J1_4 ([ChCo82]_).
Parameters
----------
f : float
Frequency (Hz)
rho : float
Resistivity (Ohm.m)
z : float
Vertical distance between source and receiver (m) | f13208:m16 |
def j1_5(f=<NUM_LIT:1>, rho=<NUM_LIT>, z=<NUM_LIT:50>): | gam = np.sqrt(<NUM_LIT>*np.pi*mu_0*f/rho)<EOL>def lhs(x):<EOL><INDENT>beta = np.sqrt(x**<NUM_LIT:2> + gam**<NUM_LIT:2>)<EOL>return x**<NUM_LIT:2>*np.exp(-beta*np.abs(z))<EOL><DEDENT>def rhs(b):<EOL><INDENT>R = np.sqrt(b**<NUM_LIT:2> + z**<NUM_LIT:2>)<EOL>return np.abs(z)*b*(gam**<NUM_LIT:2>*R**<NUM_LIT:2> + <NUM_LIT:3>... | r"""Hankel transform pair J1_5 ([ChCo82]_).
Parameters
----------
f : float
Frequency (Hz)
rho : float
Resistivity (Ohm.m)
z : float
Vertical distance between source and receiver (m) | f13208:m17 |
def sin_1(a=<NUM_LIT:1>): | def lhs(x):<EOL><INDENT>return x*np.exp(-a**<NUM_LIT:2>*x**<NUM_LIT:2>)<EOL><DEDENT>def rhs(b):<EOL><INDENT>return np.sqrt(np.pi)*b*np.exp(-b**<NUM_LIT:2>/(<NUM_LIT:4>*a**<NUM_LIT:2>))/(<NUM_LIT:4>*a**<NUM_LIT:3>)<EOL><DEDENT>return Ghosh('<STR_LIT>', lhs, rhs)<EOL> | r"""Fourier sine transform pair sin_1 ([Ande75]_). | f13208:m18 |
def sin_2(a=<NUM_LIT:1>): | def lhs(x):<EOL><INDENT>return np.exp(-a*x)<EOL><DEDENT>def rhs(b):<EOL><INDENT>return b/(b**<NUM_LIT:2> + a**<NUM_LIT:2>)<EOL><DEDENT>return Ghosh('<STR_LIT>', lhs, rhs)<EOL> | r"""Fourier sine transform pair sin_2 ([Ande75]_). | f13208:m19 |
def sin_3(a=<NUM_LIT:1>): | def lhs(x):<EOL><INDENT>return x/(a**<NUM_LIT:2> + x**<NUM_LIT:2>)<EOL><DEDENT>def rhs(b):<EOL><INDENT>return np.pi*np.exp(-a*b)/<NUM_LIT:2><EOL><DEDENT>return Ghosh('<STR_LIT>', lhs, rhs)<EOL> | r"""Fourier sine transform pair sin_3 ([Ande75]_). | f13208:m20 |
def cos_1(a=<NUM_LIT:1>): | def lhs(x):<EOL><INDENT>return np.exp(-a**<NUM_LIT:2>*x**<NUM_LIT:2>)<EOL><DEDENT>def rhs(b):<EOL><INDENT>return np.sqrt(np.pi)*np.exp(-b**<NUM_LIT:2>/(<NUM_LIT:4>*a**<NUM_LIT:2>))/(<NUM_LIT:2>*a)<EOL><DEDENT>return Ghosh('<STR_LIT>', lhs, rhs)<EOL> | r"""Fourier cosine transform pair cos_1 ([Ande75]_). | f13208:m21 |
def cos_2(a=<NUM_LIT:1>): | def lhs(x):<EOL><INDENT>return np.exp(-a*x)<EOL><DEDENT>def rhs(b):<EOL><INDENT>return a/(b**<NUM_LIT:2> + a**<NUM_LIT:2>)<EOL><DEDENT>return Ghosh('<STR_LIT>', lhs, rhs)<EOL> | r"""Fourier cosine transform pair cos_2 ([Ande75]_). | f13208:m22 |
def cos_3(a=<NUM_LIT:1>): | def lhs(x):<EOL><INDENT>return <NUM_LIT:1>/(a**<NUM_LIT:2> + x**<NUM_LIT:2>)<EOL><DEDENT>def rhs(b):<EOL><INDENT>return np.pi*np.exp(-a*b)/(<NUM_LIT:2>*a)<EOL><DEDENT>return Ghosh('<STR_LIT>', lhs, rhs)<EOL> | r"""Fourier cosine transform pair cos_3 ([Ande75]_). | f13208:m23 |
def empy_hankel(ftype, zsrc, zrec, res, freqtime, depth=None, aniso=None,<EOL>epermH=None, epermV=None, mpermH=None, mpermV=None,<EOL>htarg=None, verblhs=<NUM_LIT:0>, verbrhs=<NUM_LIT:0>): | <EOL>if isinstance(ftype, list):<EOL><INDENT>out = []<EOL>for f in ftype:<EOL><INDENT>out.append(empy_hankel(f, zsrc, zrec, res, freqtime, depth, aniso,<EOL>epermH, epermV, mpermH, mpermV, htarg,<EOL>verblhs, verbrhs))<EOL><DEDENT>return out<EOL><DEDENT>model = {'<STR_LIT:src>': [<NUM_LIT:0>, <NUM_LIT:0>, zsrc],<EOL>'<... | r"""Numerical transform pair with empymod.
All parameters except ``ftype``, ``verblhs``, and ``verbrhs`` correspond to
the input parameters to ``empymod.dipole``. See there for more information.
Note that if depth=None or [], the analytical full-space solutions will be
used (much faster).
Paramet... | f13208:m24 |
def _get_min_val(spaceshift, *params): | <EOL>spacing, shift = spaceshift<EOL>n, fI, fC, r, r_def, error, reim, cvar, verb, plot, log = params<EOL>dlf = _calculate_filter(n, spacing, shift, fI, r_def, reim, '<STR_LIT>')<EOL>k = dlf.base/r[:, None]<EOL>for i, f in enumerate(fC):<EOL><INDENT>lhs = f.lhs(k)<EOL>if f.name == '<STR_LIT>':<EOL><INDENT>rhs0 = np.dot... | r"""Calculate minimum resolved amplitude or maximum r. | f13208:m25 |
def _calculate_filter(n, spacing, shift, fI, r_def, reim, name): | <EOL>base = np.exp(spacing*(np.arange(n)-n//<NUM_LIT:2>) + shift)<EOL>r = np.logspace(np.log10(<NUM_LIT:1>/np.max(base)) - r_def[<NUM_LIT:0>],<EOL>np.log10(<NUM_LIT:1>/np.min(base)) + r_def[<NUM_LIT:1>], r_def[<NUM_LIT:2>]*n)<EOL>k = base/r[:, None]<EOL>dlf = DigitalFilter(name.split('<STR_LIT:.>')[<NUM_LIT:0>])<EOL>dl... | r"""Calculate filter for this spacing, shift, n. | f13208:m26 |
def _ls2ar(inp, strinp): | <EOL>if np.size(inp) == <NUM_LIT:1>:<EOL><INDENT>start = np.squeeze(inp)<EOL>stop = start+<NUM_LIT:1><EOL>num = <NUM_LIT:1><EOL><DEDENT>elif np.size(inp) == <NUM_LIT:3>:<EOL><INDENT>start = inp[<NUM_LIT:0>]<EOL>stop = inp[<NUM_LIT:1>]<EOL>num = inp[<NUM_LIT:2>]<EOL><DEDENT>else:<EOL><INDENT>print("<STR_LIT>"+strinp+"<S... | r"""Convert float or linspace-input to arange/slice-input for brute. | f13208:m27 |
def _print_count(log): | log['<STR_LIT>'] += <NUM_LIT:1> <EOL>cp = log['<STR_LIT>']/log['<STR_LIT>']*<NUM_LIT:100> <EOL>if log['<STR_LIT>'] == <NUM_LIT:0>: <EOL><INDENT>pass <EOL><DEDENT>elif log['<STR_LIT>'] > log['<STR_LIT>']: <EOL><INDENT>print("<STR_LIT>" % (log['<STR_LIT>']-log['<STR_LIT>']), end='<STR_LI... | r"""Print run-count information. | f13208:m28 |
def __init__(self, name, lhs, rhs): | self.name = name<EOL>self.lhs = lhs<EOL>self.rhs = rhs<EOL> | r"""Add the filter name, lhs, and rhs. | f13208:c0:m0 |
def versions(mode=None, add_pckg=None, ncol=<NUM_LIT:4>): | <EOL>mesg = ("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL>warnings.warn(mesg, DeprecationWarning)<EOL>return Versions(add_pckg, ncol)<EOL> | r"""Old func-way of class `Versions`, here for backwards compatibility.
``mode`` is not used any longer, dummy here. | f13209:m0 |
def __init__(self, add_pckg=None, ncol=<NUM_LIT:4>): | self.add_pckg = add_pckg<EOL>self.ncol = ncol<EOL> | r"""Print date, time, and version information.
Print date, time, and package version information in any environment
(Jupyter notebook, IPython console, Python console, QT console), either
as html-table (notebook) or as plain text (anywhere).
This script was heavily inspired by:
... | f13209:c0:m0 |
def __repr__(self): | <EOL>n = <NUM_LIT><EOL>text = '<STR_LIT:\n>' + n*'<STR_LIT:->' + '<STR_LIT:\n>'<EOL>text += time.strftime('<STR_LIT>')<EOL>text += '<STR_LIT>'.format(platform.system())+'<STR_LIT>'<EOL>text += '<STR_LIT>'.format(multiprocessing.cpu_count())+'<STR_LIT>'<EOL>for pckg in self._get_packages(self.add_pckg):<EOL><INDENT>text... | Plain text information. | f13209:c0:m1 |
def _repr_html_(self): | <EOL>ncol = int(self.ncol)<EOL>border = "<STR_LIT>"<EOL>def colspan(html, txt, ncol, nrow):<EOL><INDENT>r"""<STR_LIT>"""<EOL>html += "<STR_LIT>"<EOL>html += "<STR_LIT>"<EOL>if nrow == <NUM_LIT:0>:<EOL><INDENT>html += "<STR_LIT>"<EOL><DEDENT>elif nrow % <NUM_LIT:2> == <NUM_LIT:0>:<EOL><INDENT>html += "<STR_LIT>"<EOL><DE... | HTML-rendered versions information. | f13209:c0:m2 |
@staticmethod<EOL><INDENT>def _get_packages(add_pckg):<DEDENT> | <EOL>pckgs = [numpy, scipy, empymod]<EOL>for module in [IPython, numexpr, matplotlib]:<EOL><INDENT>if module:<EOL><INDENT>pckgs += [module]<EOL><DEDENT><DEDENT>if add_pckg is not None:<EOL><INDENT>if isinstance(add_pckg, tuple):<EOL><INDENT>add_pckg = list(add_pckg)<EOL><DEDENT>if not isinstance(add_pckg, list):<EOL><I... | r"""Create list of packages. | f13209:c0:m3 |
def dipole(src, rec, depth, res, freqtime, aniso=None, eperm=None, mperm=None,<EOL>verb=<NUM_LIT:2>): | <EOL>t0 = printstartfinish(verb)<EOL>model = check_model(depth, res, aniso, eperm, eperm, mperm, mperm, False,<EOL>verb)<EOL>depth, res, aniso, epermH, epermV, mpermH, mpermV, _ = model<EOL>frequency = check_frequency(freqtime, res, aniso, epermH, epermV, mpermH,<EOL>mpermV, verb)<EOL>freq, etaH, etaV, zetaH, zetaV = f... | r"""Return the electromagnetic field due to a dipole source.
This is a modified version of ``empymod.model.dipole()``. It returns the
separated contributions of TM--, TM-+, TM+-, TM++, TMdirect, TE--, TE-+,
TE+-, TE++, and TEdirect.
Parameters
----------
src, rec : list of floats or arrays
... | f13210:m0 |
def greenfct(zsrc, zrec, lsrc, lrec, depth, etaH, etaV, zetaH, zetaV, lambd): | <EOL>for TM in [True, False]:<EOL><INDENT>if TM:<EOL><INDENT>e_zH, e_zV, z_eH = etaH, etaV, zetaH <EOL><DEDENT>else:<EOL><INDENT>e_zH, e_zV, z_eH = zetaH, zetaV, etaH <EOL><DEDENT>Gam = np.sqrt((e_zH/e_zV)[:, None, :, None] *<EOL>(lambd*lambd)[None, :, None, :] +<EOL>(z_eH*e_zH)[:, None, :, None])<EOL>lrecGam = Gam[... | r"""Calculate Green's function for TM and TE.
This is a modified version of empymod.kernel.greenfct(). See the original
version for more information. | f13210:m1 |
def fields(depth, Rp, Rm, Gam, lrec, lsrc, zsrc, TM): | <EOL>first_layer = lsrc == <NUM_LIT:0><EOL>last_layer = lsrc == depth.size-<NUM_LIT:1><EOL>if lsrc != depth.size-<NUM_LIT:1>:<EOL><INDENT>ds = depth[lsrc+<NUM_LIT:1>]-depth[lsrc]<EOL>dp = depth[lsrc+<NUM_LIT:1>]-zsrc<EOL><DEDENT>dm = zsrc-depth[lsrc]<EOL>Rmp = Rm<EOL>Rpm = Rp<EOL>if TM:<EOL><INDENT>plus = False<EOL><DE... | r"""Calculate Pu+, Pu-, Pd+, Pd-.
This is a modified version of empymod.kernel.fields(). See the original
version for more information. | f13210:m2 |
def __init__(self, auth, api='<STR_LIT>', **kwargs): | self.api = api<EOL>self.log = auth.log<EOL>try:<EOL><INDENT>self.url = '<STR_LIT>' % (auth.get_url(), self.api)<EOL><DEDENT>except AttributeError:<EOL><INDENT>self.url = '<STR_LIT>' % self.api<EOL><DEDENT>try:<EOL><INDENT>self.auth = auth.get_auth()<EOL><DEDENT>except AttributeError:<EOL><INDENT>self.auth = auth<EOL><D... | Search the logs.
Args:
auth (Client): Authentication object
api (str): Api endpath | f13218:c0:m0 |
def query(self, criteria, **opts): | time_now = datetime.datetime.now().replace(second=<NUM_LIT:0>, microsecond=<NUM_LIT:0>)<EOL>right_now = time_now.isoformat()<EOL>minutes_ago = (time_now - datetime.timedelta(minutes=<NUM_LIT:15>)).isoformat()<EOL>formats = opts.get('<STR_LIT>', '<STR_LIT>')<EOL>timezone = opts.get('<STR_LIT>', '<STR_LIT>')<EOL>time_fro... | Returns a dict of the query, including the results
:param critera: string of search criteria
:param **opts:
:formats: json/xml (default: json)
:timezone: timezone to use (default: UTC)
:time_from: 15m ago from now (datetime)
:time_t... | f13218:c0:m1 |
def __init__(self, auth, **kwargs): | self.auth = auth<EOL>self.protocol = kwargs.get('<STR_LIT>', '<STR_LIT>')<EOL>self.domain = kwargs.get('<STR_LIT>', '<STR_LIT>')<EOL>self.api = kwargs.get('<STR_LIT>', '<STR_LIT>')<EOL>api_path = '<STR_LIT:%s>' % self.api<EOL>self.url = '<STR_LIT>' % (self.protocol, self.domain, api_path)<EOL>self._debug_mode = kwargs.... | Initializes Client object.
Args:
auth (tuple): Authentication object
api (str): Api endpath | f13219:c0:m0 |
def get_url(self): | return self.url<EOL> | Returns full api url | f13219:c0:m1 |
def get_auth(self): | return self.auth<EOL> | Returns api auth details | f13219:c0:m2 |
def __init__(self, auth, api='<STR_LIT>', **kwargs): | self.api = api<EOL>self.collector_id = None<EOL>self.log = auth.log<EOL>try:<EOL><INDENT>self.url = '<STR_LIT>' % (auth.get_url(), self.api)<EOL><DEDENT>except AttributeError:<EOL><INDENT>self.url = '<STR_LIT>' % self.api<EOL><DEDENT>try:<EOL><INDENT>self.auth = auth.get_auth()<EOL><DEDENT>except AttributeError:<EOL><I... | Access sumologic Collectors.
Args:
auth (Client): Authentication object
api (str): Api endpath | f13221:c0:m0 |
def get_collectors(self, limit=<NUM_LIT:1000>, offset=<NUM_LIT:0>): | options = {<EOL>'<STR_LIT>': limit,<EOL>'<STR_LIT>': offset,<EOL>}<EOL>request = requests.get(self.url, params=options, auth=self.auth)<EOL>try:<EOL><INDENT>results = request.json()['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>results = request.json()<EOL><DEDENT>except json.decoder.JSONDecodeError:<EOL><INDEN... | Returns a dict of collectors.
Args:
limit (int): number of collectors to return
offset (int): the offset of where the list of collectors should begin from | f13221:c0:m1 |
def find(self, name): | collectors = self.get_collectors()<EOL>for collector in collectors:<EOL><INDENT>if name.lower() == collector['<STR_LIT:name>'].lower():<EOL><INDENT>self.collector_id = collector['<STR_LIT:id>']<EOL>return collector<EOL><DEDENT><DEDENT>return {'<STR_LIT:status>': '<STR_LIT>'}<EOL> | Returns a dict of collector's details if found.
Args:
name (str): name of collector searching for | f13221:c0:m2 |
def delete(self, collector_id=None): | cid = self.collector_id<EOL>if collector_id:<EOL><INDENT>cid = collector_id<EOL><DEDENT>url = '<STR_LIT>'.format(self.url, cid)<EOL>request = requests.delete(url, auth=self.auth)<EOL>try:<EOL><INDENT>response = request.json()<EOL><DEDENT>except ValueError:<EOL><INDENT>response = {<EOL>u'<STR_LIT:message>': u'<STR_LIT>'... | Delete a collector from inventory.
Args:
collector_id (int): id of collector (optional) | f13221:c0:m3 |
def info(self, collector_id): | cid = self.collector_id<EOL>if collector_id:<EOL><INDENT>cid = collector_id<EOL><DEDENT>url = '<STR_LIT>'.format(self.url, cid)<EOL>request = requests.get(url, auth=self.auth)<EOL>return request.json()<EOL> | Return a dict of collector.
Args:
collector_id (int): id of collector (optional) | f13221:c0:m4 |
def get_id(self): | return self.collector_id<EOL> | Return the collector's id | f13221:c0:m5 |
def get_logging_level(debug): | level = logging.INFO<EOL>if debug:<EOL><INDENT>level = logging.DEBUG<EOL><DEDENT>return level<EOL> | Returns logging level based on boolean | f13222:m0 |
@staticmethod<EOL><INDENT>def _strip_top_comments(lines: Sequence[str], line_separator: str) -> str:<DEDENT> | lines = copy.copy(lines)<EOL>while lines and lines[<NUM_LIT:0>].startswith("<STR_LIT:#>"):<EOL><INDENT>lines = lines[<NUM_LIT:1>:]<EOL><DEDENT>return line_separator.join(lines)<EOL> | Strips # comments that exist at the top of the given lines | f13225:c0:m5 |
def place_module(self, module_name: str) -> Optional[str]: | return self.finder.find(module_name)<EOL> | Tries to determine if a module is a python std import, third party import, or project code:
if it can't determine - it assumes it is project code | f13225:c0:m6 |
def _get_line(self) -> str: | line = self.in_lines[self.index]<EOL>self.index += <NUM_LIT:1><EOL>return line<EOL> | Returns the current line from the file while incrementing the index. | f13225:c0:m7 |
@staticmethod<EOL><INDENT>def _import_type(line: str) -> Optional[str]:<DEDENT> | if "<STR_LIT>" in line or "<STR_LIT>" in line:<EOL><INDENT>return None<EOL><DEDENT>elif line.startswith('<STR_LIT>'):<EOL><INDENT>return "<STR_LIT>"<EOL><DEDENT>elif line.startswith('<STR_LIT>'):<EOL><INDENT>return "<STR_LIT>"<EOL><DEDENT> | If the current line is an import line it will return its type (from or straight) | f13225:c0:m8 |
def _at_end(self) -> bool: | return self.index == self.number_of_lines<EOL> | returns True if we are at the end of the file. | f13225:c0:m9 |
def _add_comments(<EOL>self,<EOL>comments: Optional[Sequence[str]],<EOL>original_string: str = "<STR_LIT>"<EOL>) -> str: | if self.config['<STR_LIT>']:<EOL><INDENT>return self._strip_comments(original_string)[<NUM_LIT:0>]<EOL><DEDENT>if not comments:<EOL><INDENT>return original_string<EOL><DEDENT>else:<EOL><INDENT>return "<STR_LIT>".format(self._strip_comments(original_string)[<NUM_LIT:0>],<EOL>self.config['<STR_LIT>'],<EOL>"<STR_LIT>".joi... | Returns a string with comments added if ignore_comments is not set. | f13225:c0:m11 |
def _wrap(self, line: str) -> str: | wrap_mode = self.config['<STR_LIT>']<EOL>if len(line) > self.config['<STR_LIT>'] and wrap_mode != WrapModes.NOQA:<EOL><INDENT>line_without_comment = line<EOL>comment = None<EOL>if '<STR_LIT:#>' in line:<EOL><INDENT>line_without_comment, comment = line.split('<STR_LIT:#>', <NUM_LIT:1>)<EOL><DEDENT>for splitter in ("<STR... | Returns an import wrapped to the specified line-length, if possible. | f13225:c0:m12 |
def _add_formatted_imports(self) -> None: | sort_ignore_case = self.config['<STR_LIT>']<EOL>sections = itertools.chain(self.sections, self.config['<STR_LIT>']) <EOL>if self.config['<STR_LIT>']:<EOL><INDENT>self.imports['<STR_LIT>'] = {'<STR_LIT>': [], '<STR_LIT>': {}}<EOL>for section in sections:<EOL><INDENT>self.imports['<STR_LIT>']['<STR_LIT>'].extend(self.im... | Adds the imports back to the file.
(at the index of the first import) sorted alphabetically and split between groups | f13225:c0:m16 |
@staticmethod<EOL><INDENT>def _strip_comments(<EOL>line: str,<EOL>comments: Optional[List[str]] = None<EOL>) -> Tuple[str, List[str], bool]:<DEDENT> | if comments is None:<EOL><INDENT>comments = []<EOL><DEDENT>new_comments = False<EOL>comment_start = line.find("<STR_LIT:#>")<EOL>if comment_start != -<NUM_LIT:1>:<EOL><INDENT>comments.append(line[comment_start + <NUM_LIT:1>:].strip())<EOL>new_comments = True<EOL>line = line[:comment_start]<EOL><DEDENT>return line, comm... | Removes comments from import line. | f13225:c0:m26 |
def _parse(self) -> None: | self._in_quote = False<EOL>self._in_top_comment = False<EOL>while not self._at_end():<EOL><INDENT>raw_line = line = self._get_line()<EOL>line = line.replace("<STR_LIT>", "<STR_LIT>")<EOL>line = line.replace("<STR_LIT:\t>", "<STR_LIT:U+0020>").replace('<STR_LIT>', '<STR_LIT>')<EOL>line = line.replace("<STR_LIT>", "<STR_... | Parses a python file taking out and categorizing imports. | f13225:c0:m29 |
def iter_source_code(paths: Iterable[str], config: MutableMapping[str, Any], skipped: List[str]) -> Iterator[str]: | if '<STR_LIT>' in config:<EOL><INDENT>config['<STR_LIT>'] = list(set(config['<STR_LIT>']).difference(config['<STR_LIT>']))<EOL><DEDENT>for path in paths:<EOL><INDENT>if os.path.isdir(path):<EOL><INDENT>for dirpath, dirnames, filenames in os.walk(path, topdown=True, followlinks=True):<EOL><INDENT>for dirname in list(dir... | Iterate over all Python source files defined in paths. | f13227:m2 |
def finalize_options(self) -> None: | self.arguments = {} <EOL>computed_settings = from_path(os.getcwd())<EOL>for key, value in computed_settings.items():<EOL><INDENT>self.arguments[key] = value<EOL><DEDENT> | Get options from config files. | f13227:c1:m1 |
def distribution_files(self) -> Iterator[str]: | <EOL>if self.distribution.packages:<EOL><INDENT>package_dirs = self.distribution.package_dir or {}<EOL>for package in self.distribution.packages:<EOL><INDENT>pkg_dir = package<EOL>if package in package_dirs:<EOL><INDENT>pkg_dir = package_dirs[package]<EOL><DEDENT>elif '<STR_LIT>' in package_dirs:<EOL><INDENT>pkg_dir = ... | Find distribution packages. | f13227:c1:m2 |
def get_output(command: str) -> bytes: | return subprocess.check_output(command.split())<EOL> | Run a command and return raw output
:param str command: the command to run
:returns: the stdout output of the command | f13228:m0 |
def get_lines(command: str) -> List[str]: | stdout = get_output(command)<EOL>return [line.strip().decode() for line in stdout.splitlines()]<EOL> | Run a command and return lines of output
:param str command: the command to run
:returns: list of whitespace-stripped lines output by command | f13228:m1 |
def git_hook(strict=False, modify=False): | <EOL>diff_cmd = "<STR_LIT>"<EOL>files_modified = get_lines(diff_cmd)<EOL>errors = <NUM_LIT:0><EOL>for filename in files_modified:<EOL><INDENT>if filename.endswith('<STR_LIT>'):<EOL><INDENT>staged_cmd = "<STR_LIT>" % filename<EOL>staged_contents = get_output(staged_cmd)<EOL>sort = SortImports(<EOL>file_path=filename,<EO... | Git pre-commit hook to check staged files for isort errors
:param bool strict - if True, return number of errors on exit,
causing the hook to fail. If False, return zero so it will
just act as a warning.
:param bool modify - if True, fix the sources if they are not
sorted properly. If False, only report re... | f13228:m2 |
def allow(self, path: str) -> bool: | return path.endswith('<STR_LIT>')<EOL> | Determine if this path should be linted. | f13229:c0:m0 |
def run(self, path: str, **meta: Any) -> List[Dict[str, Any]]: | with open(os.devnull, '<STR_LIT:w>') as devnull:<EOL><INDENT>sys.stdout = devnull<EOL>if SortImports(path, check=True).incorrectly_sorted:<EOL><INDENT>return [{<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>'<STR_LIT:text>': '<STR_LIT>',<EOL>'<STR_LIT:type>': '<STR_LIT>'<EOL>}]<EOL><DEDENT>else:<EOL><... | Lint the file. Return an array of error dicts if appropriate. | f13229:c0:m1 |
def nsorted(<EOL>to_sort: Iterable[str],<EOL>key: Optional[Callable[[str], Any]] = None<EOL>) -> List[str]: | if key is None:<EOL><INDENT>key_callback = _natural_keys<EOL><DEDENT>else:<EOL><INDENT>def key_callback(text: str) -> List[Any]:<EOL><INDENT>return _natural_keys(key(text)) <EOL><DEDENT><DEDENT>return sorted(to_sort, key=key_callback)<EOL> | Returns a naturally sorted list | f13230:m2 |
def _parse_known_pattern(self, pattern: str) -> List[str]: | if pattern.endswith(os.path.sep):<EOL><INDENT>patterns = [<EOL>filename<EOL>for filename in os.listdir(pattern)<EOL>if os.path.isdir(os.path.join(pattern, filename))<EOL>]<EOL><DEDENT>else:<EOL><INDENT>patterns = [pattern]<EOL><DEDENT>return patterns<EOL> | Expand pattern if identified as a directory and return found sub packages | f13233:c3:m1 |
@staticmethod<EOL><INDENT>def _load_mapping() -> Optional[Dict[str, str]]:<DEDENT> | if not pipreqs:<EOL><INDENT>return None<EOL><DEDENT>path = os.path.dirname(inspect.getfile(pipreqs))<EOL>path = os.path.join(path, '<STR_LIT>')<EOL>with open(path) as f:<EOL><INDENT>mappings = {} <EOL>for line in f:<EOL><INDENT>import_name, _, pypi_name = line.strip().partition("<STR_LIT::>")<EOL>mappings[pypi_name] =... | Return list of mappings `package_name -> module_name`
Example:
django-haystack -> haystack | f13233:c5:m3 |
def _load_names(self) -> List[str]: | names = []<EOL>for path in self._get_files():<EOL><INDENT>for name in self._get_names(path):<EOL><INDENT>names.append(self._normalize_name(name))<EOL><DEDENT><DEDENT>return names<EOL> | Return list of thirdparty modules from requirements | f13233:c5:m4 |
def _get_files(self) -> Iterator[str]: | path = os.path.abspath(self.path)<EOL>if os.path.isfile(path):<EOL><INDENT>path = os.path.dirname(path)<EOL><DEDENT>for path in self._get_parents(path):<EOL><INDENT>for file_path in self._get_files_from_dir(path):<EOL><INDENT>yield file_path<EOL><DEDENT><DEDENT> | Return paths to all requirements files | f13233:c5:m6 |
def _normalize_name(self, name: str) -> str: | if self.mapping:<EOL><INDENT>name = self.mapping.get(name, name)<EOL><DEDENT>return name.lower().replace('<STR_LIT:->', '<STR_LIT:_>')<EOL> | Convert package name to module name
Examples:
Django -> django
django-haystack -> django_haystack
Flask-RESTFul -> flask_restful | f13233:c5:m7 |
def _get_files_from_dir(self, path: str) -> Iterator[str]: | return RequirementsFinder._get_files_from_dir_cached(path)<EOL> | Return paths to requirements files from passed dir. | f13233:c6:m0 |
def _get_names(self, path: str) -> Iterator[str]: | for i in RequirementsFinder._get_names_cached(path):<EOL><INDENT>yield i<EOL><DEDENT> | Load required packages from path to requirements file | f13233:c6:m2 |
def file_should_be_skipped(<EOL>filename: str,<EOL>config: Mapping[str, Any],<EOL>path: str = '<STR_LIT>'<EOL>) -> bool: | os_path = os.path.join(path, filename)<EOL>normalized_path = os_path.replace('<STR_LIT:\\>', '<STR_LIT:/>')<EOL>if normalized_path[<NUM_LIT:1>:<NUM_LIT:2>] == '<STR_LIT::>':<EOL><INDENT>normalized_path = normalized_path[<NUM_LIT:2>:]<EOL><DEDENT>if path and config['<STR_LIT>']:<EOL><INDENT>check_exclude = '<STR_LIT:/>'... | Returns True if the file and/or folder should be skipped based on the passed in settings. | f13234:m8 |
def exists_case_sensitive(path: str) -> bool: | result = os.path.exists(path)<EOL>if (sys.platform.startswith('<STR_LIT>') or sys.platform == '<STR_LIT>') and result:<EOL><INDENT>directory, basename = os.path.split(path)<EOL>result = basename in os.listdir(directory)<EOL><DEDENT>return result<EOL> | Returns if the given path exists and also matches the case on Windows.
When finding files that can be imported, it is important for the cases to match because while
file os.path.exists("module.py") and os.path.exists("MODULE.py") both return True on Windows, Python
can only import using the case of the real file. | f13235:m0 |
@contextmanager<EOL>def chdir(path: str) -> Iterator[None]: | curdir = os.getcwd()<EOL>os.chdir(path)<EOL>try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>os.chdir(curdir)<EOL><DEDENT> | Context manager for changing dir and restoring previous workdir after exit. | f13235:m1 |
def union(a: Iterable[Any], b: Iterable[Any]) -> List[Any]: | u = [] <EOL>for item in a:<EOL><INDENT>if item not in u:<EOL><INDENT>u.append(item)<EOL><DEDENT><DEDENT>for item in b:<EOL><INDENT>if item not in u:<EOL><INDENT>u.append(item)<EOL><DEDENT><DEDENT>return u<EOL> | Return a list of items that are in `a` or `b` | f13235:m2 |
def difference(a: Iterable[Any], b: Container[Any]) -> List[Any]: | d = []<EOL>for item in a:<EOL><INDENT>if item not in b:<EOL><INDENT>d.append(item)<EOL><DEDENT><DEDENT>return d<EOL> | Return a list of items from `a` that are not in `b`. | f13235:m3 |
def sort_kate_imports(add_imports=(), remove_imports=()): | document = kate.activeDocument()<EOL>view = document.activeView()<EOL>position = view.cursorPosition()<EOL>selection = view.selectionRange()<EOL>sorter = SortImports(file_contents=document.text(), add_imports=add_imports, remove_imports=remove_imports,<EOL>settings_path=os.path.dirname(os.path.abspath(str(document.url(... | Sorts imports within Kate while maintaining cursor position and selection, even if length of file changes. | f13238:m0 |
@kate.action<EOL>def sort_imports(): | sort_kate_imports()<EOL> | Sort Imports | f13238:m1 |
@kate.action<EOL>def add_imports(): | text, ok = QtGui.QInputDialog.getText(None,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>')<EOL>if ok:<EOL><INDENT>sort_kate_imports(add_imports=text.split("<STR_LIT:;>"))<EOL><DEDENT> | Add Imports | f13238:m2 |
@kate.action<EOL>def remove_imports(): | text, ok = QtGui.QInputDialog.getText(None,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>')<EOL>if ok:<EOL><INDENT>sort_kate_imports(remove_imports=text.split("<STR_LIT:;>"))<EOL><DEDENT> | Remove Imports | f13238:m3 |
def sort_kate_imports(add_imports=(), remove_imports=()): | document = kate.activeDocument()<EOL>view = document.activeView()<EOL>position = view.cursorPosition()<EOL>selection = view.selectionRange()<EOL>sorter = SortImports(file_contents=document.text(), add_imports=add_imports, remove_imports=remove_imports,<EOL>settings_path=os.path.dirname(os.path.abspath(str(document.url(... | Sorts imports within Kate while maintaining cursor position and selection, even if length of file changes. | f13239:m0 |
def split_task_parameters(line): | if line is None:<EOL><INDENT>result = []<EOL><DEDENT>else:<EOL><INDENT>result = [parameter.strip() for parameter in line.split("<STR_LIT:U+002C>")]<EOL><DEDENT>return result<EOL> | Split a string of comma separated words. | f13241:m0 |
def find_tasks(lines): | tasks = []<EOL>linenumbers = []<EOL>pattern = re.compile(TASK_PATTERN)<EOL>for n, line in enumerate(lines):<EOL><INDENT>if "<STR_LIT:#>" in line and "<STR_LIT>" in line:<EOL><INDENT>m = pattern.match(line)<EOL>if m is not None:<EOL><INDENT>groupdict = m.groupdict()<EOL>linenumbers.append(n)<EOL>for key in groupdict:<EO... | Find task lines and corresponding line numbers in a list of lines. | f13241:m2 |
def create_environment(preamble): | environment = copy.deepcopy(os.environ)<EOL>for line in preamble:<EOL><INDENT>logging.debug(line)<EOL>if "<STR_LIT:=>" in line and not line.startswith("<STR_LIT:#>"):<EOL><INDENT>tmp = line.split("<STR_LIT:=>")<EOL>key = tmp[<NUM_LIT:0>].strip()<EOL>value = tmp[<NUM_LIT:1>].strip()<EOL>logging.debug(<EOL>"<STR_LIT>".fo... | Create a dictionary of variables obtained from the preamble of
the task file and the environment the program is running on. | f13241:m3 |
def parse_input_file(text, variables=None): | text = find_includes(text)<EOL>lines = text.splitlines()<EOL>tasks, linenumbers = find_tasks(lines)<EOL>preamble = [line for line in lines[:linenumbers[<NUM_LIT:0>]]]<EOL>logging.debug("<STR_LIT>".format("<STR_LIT:\n>".join(preamble)))<EOL>if variables is not None:<EOL><INDENT>preamble += "<STR_LIT:\n>" + "<STR_LIT:\n>... | Parser for a file with syntax somewhat similar to Drake. | f13241:m4 |
def check_inputs(self): | self.inputs = self.expand_filenames(self.inputs)<EOL>result = False<EOL>if len(self.inputs) == <NUM_LIT:0> or self.files_exist(self.inputs):<EOL><INDENT>result = True<EOL><DEDENT>else:<EOL><INDENT>print("<STR_LIT>")<EOL><DEDENT>return result<EOL> | Check for the existence of input files | f13242:c2:m2 |
def check_outputs(self): | self.outputs = self.expand_filenames(self.outputs)<EOL>result = False<EOL>if self.files_exist(self.outputs):<EOL><INDENT>if self.dependencies_are_newer(self.outputs, self.inputs):<EOL><INDENT>result = True<EOL>print("<STR_LIT>")<EOL>print("<STR_LIT>")<EOL><DEDENT>elif self.force:<EOL><INDENT>print("<STR_LIT>")<EOL>prin... | Check for the existence of output files | f13242:c2:m3 |
def expand_variables(self): | self.environment["<STR_LIT>"] = "<STR_LIT:U+0020>".join(self.inputs)<EOL>self.environment["<STR_LIT>"] = "<STR_LIT:U+0020>".join(self.outputs)<EOL>for n, input_file in enumerate(self.inputs):<EOL><INDENT>self.environment["<STR_LIT>".format(n +<NUM_LIT:1>)] = input_file<EOL><DEDENT>for n, output_file in enumerate(self.o... | Expand variables in the task code.
Only variables who use the $[<variable name>] format are expanded.
Variables using the $<variable name> and ${<variable name>} formats
are expanded by the shell (in the cases where bash is the interpreter. | f13242:c2:m4 |
def expand_filenames(self, filenames): | results = []<EOL>for filename in filenames:<EOL><INDENT>result = filename<EOL>if "<STR_LIT:$>" in filename:<EOL><INDENT>template = Template(filename)<EOL>result = template.substitute(**self.environment)<EOL>logging.debug(<EOL>"<STR_LIT>".format(filename, result))<EOL><DEDENT>if any([pattern in result for pattern in "<S... | Expand a list of filenames using environment variables,
followed by expansion of shell-style wildcards. | f13242:c2:m5 |
def files_exist(self, filenames): | return all([os.path.exists(os.path.abspath(filename)) and os.path.isfile(os.path.abspath(filename))<EOL>for filename in filenames])<EOL> | Check if all files in a given list exist. | f13242:c2:m6 |
def dependencies_are_newer(self, files, dependencies): | dependency_mtimes = [<EOL>os.path.getmtime(filename) for filename in dependencies]<EOL>file_mtimes = [os.path.getmtime(filename) for filename in files]<EOL>result = False<EOL>for file_mtime in file_mtimes:<EOL><INDENT>for dependency_mtime in dependency_mtimes:<EOL><INDENT>if dependency_mtime > file_mtime:<EOL><INDENT>r... | For two lists of files, check if any file in the
second list is newer than any file of the first. | f13242:c2:m7 |
def __call__(self): | print("<STR_LIT>".format(self.order, self))<EOL>if self.check_inputs() and self.check_outputs():<EOL><INDENT>self.expand_variables()<EOL>self.mktemp_file()<EOL>self.f.write("<STR_LIT:\n>".join(self.code) + "<STR_LIT:\n>")<EOL>self.f.close()<EOL>logging.debug("<STR_LIT>".format(self.environment))<EOL>print("<STR_LIT>".f... | Invoque an interpreter to execute the task's code. | f13242:c2:m8 |
def mktemp_file(self): | if not(os.path.exists(self.__dirname)):<EOL><INDENT>logging.debug("<STR_LIT>".format(self.__dirname))<EOL>os.mkdir(self.__dirname)<EOL><DEDENT>elif not(os.path.isdir(self.__dirname)):<EOL><INDENT>raise TempDirIsFileException(<EOL>"<STR_LIT>" %<EOL>self.__dirname)<EOL><DEDENT>self.f = tempfile.NamedTemporaryFile(dir=sel... | Create a temporary file in the '.faz' directory for
the code to feed to the interpreter. | f13242:c2:m9 |
def faz(input_file, variables=None): | logging.debug("<STR_LIT>".format(input_file))<EOL>tasks = parse_input_file(input_file, variables=variables)<EOL>print("<STR_LIT>".format(len(tasks)))<EOL>graph = DependencyGraph(tasks)<EOL>graph.show_tasks()<EOL>graph.execute()<EOL> | FAZ entry point. | f13243:m0 |
def _build_graph(self): | self._graph.add_nodes_from(self.tasks)<EOL>for node1 in self._graph.nodes:<EOL><INDENT>for node2 in self._graph.nodes:<EOL><INDENT>for input_file in node1.inputs:<EOL><INDENT>for output_file in node2.outputs:<EOL><INDENT>if output_file == input_file:<EOL><INDENT>self._graph.add_edge(node2, node1)<EOL><DEDENT><DEDENT><D... | Produce a dependency graph based on a list
of tasks produced by the parser. | f13245:c2:m1 |
def execute(self): | for task in self.tasks:<EOL><INDENT>print(<NUM_LIT> * "<STR_LIT:*>")<EOL>task()<EOL>print(<NUM_LIT> * "<STR_LIT:*>")<EOL><DEDENT> | Execute tasks in the graph (already in order). | f13245:c2:m3 |
def parse_error(self, response): | error_code = response.split('<STR_LIT:U+0020>')[<NUM_LIT:0>]<EOL>if error_code in self.EXCEPTION_CLASSES:<EOL><INDENT>response = response[len(error_code) + <NUM_LIT:1>:]<EOL>return self.EXCEPTION_CLASSES[error_code](response)<EOL><DEDENT>return ResponseError(response)<EOL> | Parse an error response | f13248:c1:m0 |
def on_connect(self, connection): | self._sock = connection._sock<EOL>self._buffer = SocketBuffer(self._sock, self.socket_read_size) <EOL>if connection.decode_responses:<EOL><INDENT>self.encoding = connection.encoding<EOL><DEDENT> | Called when the socket connects | f13248:c3:m2 |
def on_disconnect(self): | if self._sock is not None:<EOL><INDENT>self._sock.close()<EOL>self._sock = None<EOL><DEDENT>if self._buffer is not None:<EOL><INDENT>self._buffer.close()<EOL>self._buffer = None<EOL><DEDENT>self.encoding = None<EOL> | Called when the socket disconnects | f13248:c3:m3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.