text stringlengths 81 112k |
|---|
Process escapes.
def process_strings(self, string, docstrings=False):
"""Process escapes."""
m = RE_STRING_TYPE.match(string)
stype = self.get_string_type(m.group(1) if m.group(1) else '')
if not self.match_string(stype) and not docstrings:
return '', False
is_bytes... |
Retrieve the Python docstrings.
def _filter(self, text, context, encoding):
"""Retrieve the Python docstrings."""
docstrings = []
strings = []
comments = []
prev_token_type = tokenize.NEWLINE
indent = ''
name = None
stack = [(context, 0, self.MODULE)]
... |
Return a set of all slots for a given class and its parents
def find_slots(cls):
"""Return a set of all slots for a given class and its parents"""
slots = set()
for c in cls.__mro__:
cslots = getattr(c, "__slots__", tuple())
if not cslots:
continue
elif isinstance(cslo... |
Check if an object is an instance of, or a subclass deriving from, a
``date``. However, it does not consider ``datetime`` or subclasses thereof
as valid dates.
:param obj: Object to test as date.
:param accept_none: If True None is considered as a valid date object.
def _is_valid_date(obj, accept_none... |
Returns an empty set. An empty set is unbounded and only contain the
empty set.
>>> intrange.empty() in intrange.empty()
True
It is unbounded but the boundaries are not infinite. Its boundaries are
returned as ``None``. Every set contains the empty set.
def empty(cls):... |
replace(lower=None, upper=None, lower_inc=None, upper_inc=None)
Returns a new instance of self with the given arguments replaced. It
takes the exact same arguments as the constructor.
>>> intrange(1, 5).replace(upper=10)
intrange([1,10))
>>> intrange(1, 10).replace(... |
Return True if this contains other. Other may be either range of same
type or scalar of same type as the boundaries.
>>> intrange(1, 10).contains(intrange(1, 5))
True
>>> intrange(1, 10).contains(intrange(5, 10))
True
>>> intrange(1, 10).contains(intr... |
Tests if this range is within `other`.
>>> a = intrange(1, 10)
>>> b = intrange(3, 8)
>>> a.contains(b)
True
>>> b.within(a)
True
This is the same as the ``self <@ other`` in PostgreSQL. One difference
however is that unlike Postg... |
Returns True if both ranges share any points.
>>> intrange(1, 10).overlap(intrange(5, 15))
True
>>> intrange(1, 5).overlap(intrange(5, 10))
False
This is the same as the ``&&`` operator for two ranges in PostgreSQL.
:param other: Range to test against.
... |
Returns True if ranges are directly next to each other but does not
overlap.
>>> intrange(1, 5).adjacent(intrange(5, 10))
True
>>> intrange(1, 5).adjacent(intrange(10, 15))
False
The empty set is not adjacent to any set.
This is the same as the ... |
Merges this range with a given range.
>>> intrange(1, 5).union(intrange(5, 10))
intrange([1,10))
>>> intrange(1, 10).union(intrange(5, 15))
intrange([1,15))
Two ranges can not be merged if the resulting range would be split in
two. This happens when the ... |
Compute the difference between this and a given range.
>>> intrange(1, 10).difference(intrange(10, 15))
intrange([1,10))
>>> intrange(1, 10).difference(intrange(5, 10))
intrange([1,5))
>>> intrange(1, 5).difference(intrange(5, 10))
intrange([1,5))... |
Returns a new range containing all points shared by both ranges. If no
points are shared an empty range is returned.
>>> intrange(1, 5).intersection(intrange(1, 10))
intrange([1,5))
>>> intrange(1, 5).intersection(intrange(5, 10))
intrange(empty)
>>> ... |
Test if this range starts with `other`. `other` may be either range or
scalar.
>>> intrange(1, 5).startswith(1)
True
>>> intrange(1, 5).startswith(intrange(1, 10))
True
:param other: Range or scalar to test.
:return: ``True`` if this range starts... |
Test if this range ends with `other`. `other` may be either range or
scalar.
>>> intrange(1, 5).endswith(4)
True
>>> intrange(1, 10).endswith(intrange(5, 10))
True
:param other: Range or scalar to test.
:return: ``True`` if this range ends with `... |
Test if this range starts after `other`. `other` may be either range or
scalar. This only takes the lower end of the ranges into consideration.
If the scalar or the lower end of the given range is greater than or
equal to this range's lower end, ``True`` is returned.
>>> intrange(1,... |
Test if this range ends before `other`. `other` may be either range or
scalar. This only takes the upper end of the ranges into consideration.
If the scalar or the upper end of the given range is less than or equal
to this range's upper end, ``True`` is returned.
>>> intrange(1, 5).... |
Test if this range `other` is strictly left of `other`.
>>> intrange(1, 5).left_of(intrange(5, 10))
True
>>> intrange(1, 10).left_of(intrange(5, 10))
False
The bitwise right shift operator ``<<`` is overloaded for this operation
too.
>>> int... |
Shift the range to the left or right with the given offset
>>> intrange(0, 5).offset(5)
intrange([5,10))
>>> intrange(5, 10).offset(-5)
intrange([0,5))
>>> intrange.empty().offset(5)
intrange(empty)
Note that range objects are immutable a... |
Create a day long daterange from for the given date.
>>> daterange.from_date(date(2000, 1, 1))
daterange([datetime.date(2000, 1, 1),datetime.date(2000, 1, 2)))
:param date: A date to convert.
:param period: The period to normalize date to. A period may be one of:
... |
Create ``daterange`` based on a year and an ISO week
:param year: Year as an integer
:param iso_week: ISO week number
:return: A new ``daterange`` for the given week
.. versionadded:: 0.4.0
def from_week(cls, year, iso_week):
"""
Create ``daterange`` based on a year an... |
Create ``daterange`` based on a year and amonth
:param year: Year as an integer
:param iso_week: Month as an integer between 1 and 12
:return: A new ``daterange`` for the given month
.. versionadded:: 0.4.0
def from_month(cls, year, month):
"""
Create ``daterange`` bas... |
Create ``daterange`` based on a year and quarter.
A quarter is considered to be:
- January through March (Q1),
- April through June (Q2),
- July through September (Q3) or,
- October through December (Q4)
:param year: Year as an integer
:param quarter: Quarter a... |
Create ``daterange`` based on a year
:param year: Year as an integer
:return: A new ``daterange`` for the given year
.. versionadded:: 0.4.0
def from_year(cls, year):
"""
Create ``daterange`` based on a year
:param year: Year as an integer
:return: A new ``dat... |
This ``PeriodRange`` represented as a naive
:class:`~spans.types.daterange`.
def daterange(self):
"""
This ``PeriodRange`` represented as a naive
:class:`~spans.types.daterange`.
"""
return daterange(
lower=self.lower,
upper=self.upper,
... |
Offset the date range by the given amount of periods.
This differs from :meth:`~spans.types.OffsetableRangeMixin.offset` on
:class:`spans.types.daterange` by not accepting a ``timedelta`` object.
Instead it expects an integer to adjust the typed date range by. The
given value may be neg... |
The period before this range.
>>> span = PeriodRange.from_date(date(2000, 1, 1), period="month")
>>> span.prev_period()
PeriodRange([datetime.date(1999, 12, 1),datetime.date(2000, 1, 1)))
:return: A new :class:`~spans.types.PeriodRange` for the period
befor... |
Provides hash of given filename.
Args:
filename (str): Name of file to hash
Returns:
(str): sha256 hash
def get_package_hashes(filename):
"""Provides hash of given filename.
Args:
filename (str): Name of file to hash
Returns:
(str): sha256 hash
"""
lo... |
Setup.
def setup(self):
"""Setup."""
self.blocks = self.config['block_comments']
self.lines = self.config['line_comments']
self.group_comments = self.config['group_comments']
# If the style isn't found, just go with CSS, then use the appropriate prefix.
self.stylesheets... |
Search for comments.
def evaluate(self, m):
"""Search for comments."""
g = m.groupdict()
if g["strings"]:
self.line_num += g['strings'].count('\n')
elif g["code"]:
self.line_num += g["code"].count('\n')
else:
if g['block']:
se... |
Extend source list.
def extend_src(self, content, context):
"""Extend source list."""
self.extend_src_text(content, context, self.block_comments, 'block-comment')
self.extend_src_text(content, context, self.line_comments, 'line-comment') |
Find content.
def find_content(self, text):
"""Find content."""
for m in self.pattern.finditer(self.norm_nl(text)):
self.evaluate(m) |
Filter JavaScript comments.
def _filter(self, text, context, encoding):
"""Filter JavaScript comments."""
content = []
self.current_encoding = encoding
self.line_num = 1
self.prev_line = -1
self.leading = ''
self.block_comments = []
self.line_comments = ... |
Load a decode array from a DFITS file.
Args:
fitsname (str): Name of DFITS file.
coordtype (str): Coordinate type included into a decode array.
'azel': Azimuth / elevation.
'radec': Right ascension / declination.
loadtype (str): Data unit of xarray.
'Tsig... |
Save a cube to a 3D-cube FITS file.
Args:
cube (xarray.DataArray): Cube to be saved.
fitsname (str): Name of output FITS file.
kwargs (optional): Other arguments common with astropy.io.fits.writeto().
def savefits(cube, fitsname, **kwargs):
"""Save a cube to a 3D-cube FITS file.
A... |
Load a dataarray from a NetCDF file.
Args:
filename (str): Filename (*.nc).
copy (bool): If True, dataarray is copied in memory. Default is True.
Returns:
dataarray (xarray.DataArray): Loaded dataarray.
def loadnetcdf(filename, copy=True):
"""Load a dataarray from a NetCDF file.
... |
Save a dataarray to a NetCDF file.
Args:
dataarray (xarray.DataArray): Dataarray to be saved.
filename (str): Filename (used as <filename>.nc).
If not spacified, random 8-character name will be used.
def savenetcdf(dataarray, filename=None):
"""Save a dataarray to a NetCDF file.
... |
Validate options.
def validate_options(self, k, v):
"""Validate options."""
super().validate_options(k, v)
if k == 'errors' and v.lower() not in ('strict', 'replace', 'ignore', 'backslashreplace'):
raise ValueError("{}: '{}' is not a valid value for '{}'".format(self.__class__.__na... |
Setup.
def setup(self):
"""Setup."""
self.normalize = self.config['normalize'].upper()
self.convert_encoding = self.config['convert_encoding'].lower()
self.errors = self.config['errors'].lower()
if self.convert_encoding:
self.convert_encoding = codecs.lookup(
... |
Convert the text.
def convert(self, text, encoding):
"""Convert the text."""
if self.normalize in ('NFC', 'NFKC', 'NFD', 'NFKD'):
text = unicodedata.normalize(self.normalize, text)
if self.convert_encoding:
text = text.encode(self.convert_encoding, self.errors).decode(s... |
Execute filter.
def sfilter(self, source):
"""Execute filter."""
text, encoding = self.convert(source.text, source.encoding)
return [filters.SourceText(text, source.context, encoding, 'text')] |
Function to sign the parameters required to create a cancellation request from the Switcheo Exchange.
Execution of this function is as follows::
sign_create_cancellation(cancellation_params=signable_params, private_key=eth_private_key)
The expected return result for this function is as follows::
... |
Function to sign the parameters required to execute a cancellation request on the Switcheo Exchange.
Execution of this function is as follows::
sign_execute_cancellation(cancellation_params=signable_params, private_key=eth_private_key)
The expected return result for this function is as follows::
... |
Function to execute the deposit request by signing the transaction generated from the create deposit function.
Execution of this function is as follows::
sign_execute_deposit(deposit_params=create_deposit, private_key=eth_private_key)
The expected return result for this function is as follows::
... |
Function to execute the order request by signing the transaction generated from the create order function.
Execution of this function is as follows::
sign_execute_order(order_params=signable_params, private_key=eth_private_key)
The expected return result for this function is as follows::
{
... |
Function to execute the withdrawal request by signing the transaction generated from the create withdrawal function.
Execution of this function is as follows::
sign_execute_withdrawal(withdrawal_params=signable_params, private_key=eth_private_key)
The expected return result for this function is as fol... |
Setup.
def setup(self):
"""Setup."""
self.additional_context = ''
self.comments = False
self.attributes = []
self.parser = 'xml'
self.type = None
self.filepattern = 'content.xml'
self.namespaces = {
'text': 'urn:oasis:names:tc:opendocument:xm... |
Determine file type.
def determine_file_type(self, z):
"""Determine file type."""
mimetype = z.read('mimetype').decode('utf-8').strip()
self.type = MIMEMAP[mimetype] |
Get zip content.
def get_zip_content(self, filename):
"""Get zip content."""
with zipfile.ZipFile(filename, 'r') as z:
self.determine_file_type(z)
for item in z.infolist():
if glob.globmatch(item.filename, self.filepattern, flags=self.FLAGS):
... |
Get content.
def get_content(self, zipbundle):
"""Get content."""
for content, filename in self.get_zip_content(zipbundle):
with io.BytesIO(content) as b:
encoding = self._analyze_file(b)
if encoding is None:
encoding = self.default_encod... |
Break on specified boundaries.
def content_break(self, el):
"""Break on specified boundaries."""
should_break = False
if self.type == 'odp':
if el.name == 'page' and el.namespace and el.namespace == self.namespaces['draw']:
should_break = True
return should_... |
Apply soft break if needed.
def soft_break(self, el, text):
"""Apply soft break if needed."""
if el.name == 'p' and el.namespace and el.namespace == self.namespaces["text"]:
text.append('\n') |
Store the text as desired.
def store_blocks(self, el, blocks, text, force_root):
"""Store the text as desired."""
self.soft_break(el, text)
if force_root or el.parent is None or self.content_break(el):
content = html.unescape(''.join(text))
if content:
... |
Extract meta data.
def extract_tag_metadata(self, el):
"""Extract meta data."""
if self.type == 'odp':
if el.namespace and el.namespace == self.namespaces['draw'] and el.name == 'page-thumbnail':
name = el.attrs.get('draw:page-number', '')
self.additional_co... |
Extract node from document if desired.
def get_sub_node(self, node):
"""Extract node from document if desired."""
subnode = node.find('office:document')
if subnode:
mimetype = subnode.attrs['office:mimetype']
self.type = MIMEMAP[mimetype]
node = node.find('o... |
Parse XML file.
def filter(self, source_file, encoding): # noqa A001
"""Parse XML file."""
sources = []
if encoding:
with codecs.open(source_file, 'r', encoding=encoding) as f:
src = f.read()
sources.extend(self._filter(src, source_file, encoding))
... |
Filter.
def sfilter(self, source):
"""Filter."""
sources = []
if source.text[:4].encode(source.encoding) != b'PK\x03\x04':
sources.extend(self._filter(source.text, source.context, source.encoding))
else:
for content, filename, enc in self.get_content(io.BytesIO(... |
Create an array as an instance of xarray.DataArray with Decode accessor.
Args:
data (numpy.ndarray): 2D (time x channel) array.
tcoords (dict, optional): Dictionary of arrays that label time axis.
chcoords (dict, optional): Dictionary of arrays that label channel axis.
scalarcoords ... |
Create an array of given shape and type, filled with zeros.
Args:
shape (sequence of ints): 2D shape of the array.
dtype (data-type, optional): Desired data-type for the array.
kwargs (optional): Other arguments of the array (*coords, attrs, and name).
Returns:
array (decode.ar... |
Create an array of given shape and type, filled with ones.
Args:
shape (sequence of ints): 2D shape of the array.
dtype (data-type, optional): Desired data-type for the array.
kwargs (optional): Other arguments of the array (*coords, attrs, and name).
Returns:
array (decode.arr... |
Create an array of given shape and type, filled with `fill_value`.
Args:
shape (sequence of ints): 2D shape of the array.
fill_value (scalar or numpy.ndarray): Fill value or array.
dtype (data-type, optional): Desired data-type for the array.
kwargs (optional): Other arguments of th... |
Create an array of given shape and type, without initializing entries.
Args:
shape (sequence of ints): 2D shape of the array.
dtype (data-type, optional): Desired data-type for the array.
kwargs (optional): Other arguments of the array (*coords, attrs, and name).
Returns:
array... |
Create an array of zeros with the same shape and type as the input array.
Args:
array (xarray.DataArray): The shape and data-type of it define
these same attributes of the output array.
dtype (data-type, optional): If specified, this function overrides
the data-type of the o... |
Create an array of ones with the same shape and type as the input array.
Args:
array (xarray.DataArray): The shape and data-type of it define
these same attributes of the output array.
dtype (data-type, optional): If spacified, this function overrides
the data-type of the ou... |
Create an array of `fill_value` with the same shape and type as the input array.
Args:
array (xarray.DataArray): The shape and data-type of it define
these same attributes of the output array.
fill_value (scalar or numpy.ndarray): Fill value or array.
dtype (data-type, optional)... |
Create an array of empty with the same shape and type as the input array.
Args:
array (xarray.DataArray): The shape and data-type of it define
these same attributes of the output array.
dtype (data-type, optional): If spacified, this function overrides
the data-type of the o... |
Iterate tasks.
def iter_tasks(matrix, names, groups):
"""Iterate tasks."""
# Build name index
name_index = dict([(task.get('name', ''), index) for index, task in enumerate(matrix)])
for index, task in enumerate(matrix):
name = task.get('name', '')
group = task.get('group', '')
... |
Spell check.
def spellcheck(config_file, names=None, groups=None, binary='', checker='', sources=None, verbose=0, debug=False):
"""Spell check."""
hunspell = None
aspell = None
spellchecker = None
config = util.read_config(config_file)
if sources is None:
sources = []
matrix = con... |
Get the error.
def get_error(self, e):
"""Get the error."""
import traceback
return traceback.format_exc() if self.debug else str(e) |
Recursively run text objects through the pipeline steps.
def _pipeline_step(self, sources, options, personal_dict, filter_index=1, flow_status=flow_control.ALLOW):
"""Recursively run text objects through the pipeline steps."""
for source in sources:
if source._has_error():
... |
Check spelling pipeline.
def _spelling_pipeline(self, sources, options, personal_dict):
"""Check spelling pipeline."""
for source in self._pipeline_step(sources, options, personal_dict):
# Don't waste time on empty strings
if source._has_error():
yield Results([... |
Walk source and parse files.
def _walk_src(self, targets, flags, pipeline):
"""Walk source and parse files."""
for target in targets:
for f in glob.iglob(target, flags=flags | glob.S):
if not os.path.isdir(f):
self.log('', 2)
self.log... |
Build up the pipeline.
def _build_pipeline(self, task):
"""Build up the pipeline."""
self.pipeline_steps = []
kwargs = {}
if self.default_encoding:
kwargs["default_encoding"] = self.default_encoding
steps = task.get('pipeline', [])
if steps is None:
... |
Get module.
def _get_module(self, module):
"""Get module."""
if isinstance(module, str):
mod = importlib.import_module(module)
for name in ('get_plugin', 'get_filter'):
attr = getattr(mod, name, None)
if attr is not None:
break
if... |
Convert text representation of flags to actual flags.
def _to_flags(self, text):
"""Convert text representation of flags to actual flags."""
flags = 0
for x in text.split('|'):
value = x.strip().upper()
if value:
flags |= self.GLOB_FLAG_MAP.get(value, 0)... |
Walk source and initiate spell check.
def run_task(self, task, source_patterns=None):
"""Walk source and initiate spell check."""
# Perform spell check
self.log('Running Task: %s...' % task.get('name', ''), 1)
# Setup filters and variables for the spell check
self.default_enco... |
Compile user dictionary.
def compile_dictionary(self, lang, wordlists, encoding, output):
"""Compile user dictionary."""
cmd = [
self.binary,
'--lang', lang,
'--encoding', codecs.lookup(filters.PYTHON_ENCODING_NAMES.get(encoding, encoding).lower()).name,
... |
Setup dictionary.
def setup_dictionary(self, task):
"""Setup dictionary."""
dictionary_options = task.get('dictionary', {})
output = os.path.abspath(dictionary_options.get('output', self.dict_bin))
lang = dictionary_options.get('lang', 'en_US')
wordlists = dictionary_options.ge... |
Compile user dictionary.
def compile_dictionary(self, lang, wordlists, encoding, output):
"""Compile user dictionary."""
wordlist = ''
try:
output_location = os.path.dirname(output)
if not os.path.exists(output_location):
os.makedirs(output_location)
... |
Spell check without the pipeline.
def spell_check_no_pipeline(self, sources, options, personal_dict):
"""Spell check without the pipeline."""
for source in sources:
if source._has_error(): # pragma: no cover
yield Results([], source.context, source.category, source.error)
... |
Setup command.
def setup_command(self, encoding, options, personal_dict, file_name=None):
"""Setup command."""
cmd = [
self.binary,
'-l'
]
if encoding:
cmd.extend(['-i', encoding])
if personal_dict:
cmd.extend(['-p', personal_di... |
TODO: dict based better than list based please
:param fields:
:param target_field:
:param etl_func:
:return:
def fusion(fields, target_field, etl_func):
"""
TODO: dict based better than list based please
:param fields:
:param target_field:
:param etl_func:
:return:
"""
... |
TODO: dict based better than list based please
:param fields:
:param error_field:
:param etl_func:
:return:
def fusion_append(fields, error_field, etl_func):
"""
TODO: dict based better than list based please
:param fields:
:param error_field:
:param etl_func:
:return:
"""... |
Get default configuration.
def setup(self):
"""Get default configuration."""
self.allow = self.config['allow']
self.halt = self.config['halt']
self.skip = self.config['skip'] |
Match the category.
def match(self, category, pattern):
"""Match the category."""
return fnmatch.fnmatch(category, pattern, flags=self.FNMATCH_FLAGS) |
Adjust the flow of source control objects.
def adjust_flow(self, category):
"""Adjust the flow of source control objects."""
status = flow_control.SKIP
for allow in self.allow:
if self.match(category, allow):
status = flow_control.ALLOW
for skip in s... |
Plot coordinates related to the time axis.
Args:
array (xarray.DataArray): Array which the coodinate information is included.
coords (list): Name of x axis and y axis.
scantypes (list): Scantypes. If None, all scantypes are used.
ax (matplotlib.axes): Axis you want to plot on.
... |
Plot timestream data.
Args:
array (xarray.DataArray): Array which the timestream data are included.
kidid (int): Kidid.
xtick (str): Type of x axis.
'time': Time.
'index': Time index.
scantypes (list): Scantypes. If None, all scantypes are used.
ax (m... |
Plot a spectrum.
Args:
cube (xarray.DataArray): Cube which the spectrum information is included.
xtick (str): Type of x axis.
'freq': Frequency [GHz].
'id': Kid id.
ytick (str): Type of y axis.
'max': Maximum.
'sum': Summation.
'me... |
Plot an intensity map.
Args:
cube (xarray.DataArray): Cube which the spectrum information is included.
kidid (int): Kidid.
ax (matplotlib.axes): Axis the figure is plotted on.
kwargs (optional): Plot options passed to ax.imshow().
def plot_chmap(cube, kidid, ax=None, **kwargs):
... |
Plot PSD (Power Spectral Density).
Args:
data (np.ndarray): Input data.
dt (float): Time between each data.
ndivide (int): Do averaging (split data into ndivide, get psd of each, and average them).
overlap_half (bool): Split data to half-overlapped regions.
ax (matplotlib.ax... |
Plot Allan variance.
Args:
data (np.ndarray): Input data.
dt (float): Time between each data.
tmax (float): Maximum time.
ax (matplotlib.axes): Axis the figure is plotted on.
kwargs (optional): Plot options passed to ax.plot().
def plotallanvar(data, dt, tmax=10, ax=None, *... |
This function is a wrapper function around the create and execute cancellation functions to help make this
processes simpler for the end user by combining these requests in 1 step.
Execution of this function is as follows::
cancel_order(order_id=order['id'], private_key=kp)
canc... |
Function to create a cancellation request for the order ID from the open orders on the order book.
Execution of this function is as follows::
create_cancellation(order_id=order['id'], private_key=kp)
The expected return result for this function is as follows::
{
... |
This function executes the order created before it and signs the transaction to be submitted to the blockchain.
Execution of this function is as follows::
execute_cancellation(cancellation_params=create_cancellation, private_key=kp)
The expected return result for this function is as follow... |
This function is a wrapper function around the create and execute deposit functions to help make this
processes simpler for the end user by combining these requests in 1 step.
Execution of this function is as follows::
deposit(asset="SWTH", amount=1.1, private_key=KeyPair)
depos... |
Function to create a deposit request by generating a transaction request from the Switcheo API.
Execution of this function is as follows::
create_deposit(asset="SWTH", amount=1.1, private_key=KeyPair)
create_deposit(asset="ETH", amount=1.1, private_key=eth_private_key)
The expe... |
Function to execute the deposit request by signing the transaction generated by the create deposit function.
Execution of this function is as follows::
execute_deposit(deposit_params=create_deposit, private_key=KeyPair)
execute_deposit(deposit_params=create_deposit, private_key=eth_priv... |
This function is a wrapper function around the create and execute order functions to help make this processes
simpler for the end user by combining these requests in 1 step.
Execution of this function is as follows::
order(pair="SWTH_NEO", side="buy",
price=0.0002, quantit... |
Function to create an order for the trade pair and details requested.
Execution of this function is as follows::
create_order(pair="SWTH_NEO", side="buy", price=0.0002, quantity=100, private_key=kp,
use_native_token=True, order_type="limit")
The expected return res... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.