index
int64 0
731k
| package
stringlengths 2
98
⌀ | name
stringlengths 1
76
| docstring
stringlengths 0
281k
⌀ | code
stringlengths 4
1.07M
⌀ | signature
stringlengths 2
42.8k
⌀ |
|---|---|---|---|---|---|
5,710 | simple_di | _ProvideClass |
used as the default value of a injected functool/method. Would be replaced by the
final value of the provider when this function/method gets called.
| class _ProvideClass:
"""
used as the default value of a injected functool/method. Would be replaced by the
final value of the provider when this function/method gets called.
"""
def __getitem__(self, provider: Provider[VT]) -> VT:
return provider # type: ignore
| () |
5,711 | simple_di | __getitem__ | null | def __getitem__(self, provider: Provider[VT]) -> VT:
return provider # type: ignore
| (self, provider: simple_di.Provider[~VT]) -> ~VT |
5,712 | simple_di | _SentinelClass | null | class _SentinelClass:
pass
| () |
5,713 | simple_di | _inject | null | def _inject(func: WrappedCallable, squeeze_none: bool) -> WrappedCallable:
if getattr(func, "_is_injected", False):
return func
sig = inspect.signature(func)
@functools.wraps(func)
def _(
*args: Optional[Union[Any, _SentinelClass]],
**kwargs: Optional[Union[Any, _SentinelClass]]
) -> Any:
if not squeeze_none:
filtered_args = tuple(a for a in args if not isinstance(a, _SentinelClass))
filtered_kwargs = {
k: v for k, v in kwargs.items() if not isinstance(v, _SentinelClass)
}
else:
filtered_args = tuple(a for a in args if a is not None)
filtered_kwargs = {k: v for k, v in kwargs.items() if v is not None}
bind = sig.bind_partial(*filtered_args, **filtered_kwargs)
bind.apply_defaults()
return func(*_inject_args(bind.args), **_inject_kwargs(bind.kwargs))
setattr(_, "_is_injected", True)
return cast(WrappedCallable, _)
| (func: ~WrappedCallable, squeeze_none: bool) -> ~WrappedCallable |
5,714 | simple_di | _inject_args | null | def _inject_args(
args: Tuple[Union[Provider[VT], Any], ...]
) -> Tuple[Union[VT, Any], ...]:
return tuple(a.get() if isinstance(a, Provider) else a for a in args)
| (args: Tuple[Union[simple_di.Provider[~VT], Any], ...]) -> Tuple[Union[~VT, Any], ...] |
5,715 | simple_di | _inject_kwargs | null | def _inject_kwargs(
kwargs: Dict[str, Union[Provider[VT], Any]]
) -> Dict[str, Union[VT, Any]]:
return {k: v.get() if isinstance(v, Provider) else v for k, v in kwargs.items()}
| (kwargs: Dict[str, Union[simple_di.Provider[~VT], Any]]) -> Dict[str, Union[~VT, Any]] |
5,716 | typing | cast | Cast a value to a type.
This returns the value unchanged. To the type checker this
signals that the return value has the designated type, but at
runtime we intentionally don't check anything (we want this
to be as fast as possible).
| def cast(typ, val):
"""Cast a value to a type.
This returns the value unchanged. To the type checker this
signals that the return value has the designated type, but at
runtime we intentionally don't check anything (we want this
to be as fast as possible).
"""
return val
| (typ, val) |
5,717 | dataclasses | dataclass | Returns the same class as was passed in, with dunder methods
added based on the fields defined in the class.
Examines PEP 526 __annotations__ to determine fields.
If init is true, an __init__() method is added to the class. If
repr is true, a __repr__() method is added. If order is true, rich
comparison dunder methods are added. If unsafe_hash is true, a
__hash__() method function is added. If frozen is true, fields may
not be assigned to after instance creation. If match_args is true,
the __match_args__ tuple is added. If kw_only is true, then by
default all fields are keyword-only. If slots is true, an
__slots__ attribute is added.
| def dataclass(cls=None, /, *, init=True, repr=True, eq=True, order=False,
unsafe_hash=False, frozen=False, match_args=True,
kw_only=False, slots=False):
"""Returns the same class as was passed in, with dunder methods
added based on the fields defined in the class.
Examines PEP 526 __annotations__ to determine fields.
If init is true, an __init__() method is added to the class. If
repr is true, a __repr__() method is added. If order is true, rich
comparison dunder methods are added. If unsafe_hash is true, a
__hash__() method function is added. If frozen is true, fields may
not be assigned to after instance creation. If match_args is true,
the __match_args__ tuple is added. If kw_only is true, then by
default all fields are keyword-only. If slots is true, an
__slots__ attribute is added.
"""
def wrap(cls):
return _process_class(cls, init, repr, eq, order, unsafe_hash,
frozen, match_args, kw_only, slots)
# See if we're being called as @dataclass or @dataclass().
if cls is None:
# We're called with parens.
return wrap
# We're called as @dataclass without parens.
return wrap(cls)
| (cls=None, /, *, init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False) |
5,721 | simple_di | inject |
used with `Provide`, inject values to provided defaults of the decorated
function/method when gets called.
| def inject(
func: Optional[WrappedCallable] = None, squeeze_none: bool = False
) -> Union[WrappedCallable, Callable[[WrappedCallable], WrappedCallable]]:
"""
used with `Provide`, inject values to provided defaults of the decorated
function/method when gets called.
"""
if func is None:
wrapper = functools.partial(_inject, squeeze_none=squeeze_none)
return cast(Callable[[WrappedCallable], WrappedCallable], wrapper)
if callable(func):
return _inject(func, squeeze_none=squeeze_none)
raise ValueError("You must pass either None or Callable")
| (func: Optional[~WrappedCallable] = None, squeeze_none: bool = False) -> Union[~WrappedCallable, Callable[[~WrappedCallable], ~WrappedCallable]] |
5,723 | typing | overload | Decorator for overloaded functions/methods.
In a stub file, place two or more stub definitions for the same
function in a row, each decorated with @overload. For example:
@overload
def utf8(value: None) -> None: ...
@overload
def utf8(value: bytes) -> bytes: ...
@overload
def utf8(value: str) -> bytes: ...
In a non-stub file (i.e. a regular .py file), do the same but
follow it with an implementation. The implementation should *not*
be decorated with @overload. For example:
@overload
def utf8(value: None) -> None: ...
@overload
def utf8(value: bytes) -> bytes: ...
@overload
def utf8(value: str) -> bytes: ...
def utf8(value):
# implementation goes here
| def overload(func):
"""Decorator for overloaded functions/methods.
In a stub file, place two or more stub definitions for the same
function in a row, each decorated with @overload. For example:
@overload
def utf8(value: None) -> None: ...
@overload
def utf8(value: bytes) -> bytes: ...
@overload
def utf8(value: str) -> bytes: ...
In a non-stub file (i.e. a regular .py file), do the same but
follow it with an implementation. The implementation should *not*
be decorated with @overload. For example:
@overload
def utf8(value: None) -> None: ...
@overload
def utf8(value: bytes) -> bytes: ...
@overload
def utf8(value: str) -> bytes: ...
def utf8(value):
# implementation goes here
"""
return _overload_dummy
| (func) |
5,724 | simple_di | sync_container |
sync container states from `from_` to `to_`
| def sync_container(from_: Any, to_: Any) -> None:
"""
sync container states from `from_` to `to_`
"""
for field in dataclasses.fields(to_):
src = field.default
target = getattr(from_, field.name, None)
if target is None:
continue
if isinstance(src, Provider):
src.__setstate__(target.__getstate__())
elif dataclasses.is_dataclass(src):
sync_container(src, target)
| (from_: Any, to_: Any) -> NoneType |
5,725 | logging | NullHandler |
This handler does nothing. It's intended to be used to avoid the
"No handlers could be found for logger XXX" one-off warning. This is
important for library code, which may contain code to log events. If a user
of the library does not configure logging, the one-off warning might be
produced; to avoid this, the library developer simply needs to instantiate
a NullHandler and add it to the top-level logger of the library module or
package.
| class NullHandler(Handler):
"""
This handler does nothing. It's intended to be used to avoid the
"No handlers could be found for logger XXX" one-off warning. This is
important for library code, which may contain code to log events. If a user
of the library does not configure logging, the one-off warning might be
produced; to avoid this, the library developer simply needs to instantiate
a NullHandler and add it to the top-level logger of the library module or
package.
"""
def handle(self, record):
"""Stub."""
def emit(self, record):
"""Stub."""
def createLock(self):
self.lock = None
def _at_fork_reinit(self):
pass
| (level=0) |
5,726 | logging | __init__ |
Initializes the instance - basically setting the formatter to None
and the filter list to empty.
| def __init__(self, level=NOTSET):
"""
Initializes the instance - basically setting the formatter to None
and the filter list to empty.
"""
Filterer.__init__(self)
self._name = None
self.level = _checkLevel(level)
self.formatter = None
self._closed = False
# Add the handler to the global _handlerList (for cleanup on shutdown)
_addHandlerRef(self)
self.createLock()
| (self, level=0) |
5,727 | logging | __repr__ | null | def __repr__(self):
level = getLevelName(self.level)
return '<%s (%s)>' % (self.__class__.__name__, level)
| (self) |
5,728 | logging | _at_fork_reinit | null | def _at_fork_reinit(self):
pass
| (self) |
5,729 | logging | acquire |
Acquire the I/O thread lock.
| def acquire(self):
"""
Acquire the I/O thread lock.
"""
if self.lock:
self.lock.acquire()
| (self) |
5,730 | logging | addFilter |
Add the specified filter to this handler.
| def addFilter(self, filter):
"""
Add the specified filter to this handler.
"""
if not (filter in self.filters):
self.filters.append(filter)
| (self, filter) |
5,731 | logging | close |
Tidy up any resources used by the handler.
This version removes the handler from an internal map of handlers,
_handlers, which is used for handler lookup by name. Subclasses
should ensure that this gets called from overridden close()
methods.
| def close(self):
"""
Tidy up any resources used by the handler.
This version removes the handler from an internal map of handlers,
_handlers, which is used for handler lookup by name. Subclasses
should ensure that this gets called from overridden close()
methods.
"""
#get the module data lock, as we're updating a shared structure.
_acquireLock()
try: #unlikely to raise an exception, but you never know...
self._closed = True
if self._name and self._name in _handlers:
del _handlers[self._name]
finally:
_releaseLock()
| (self) |
5,732 | logging | createLock | null | def createLock(self):
self.lock = None
| (self) |
5,733 | logging | emit | Stub. | def emit(self, record):
"""Stub."""
| (self, record) |
5,734 | logging | filter |
Determine if a record is loggable by consulting all the filters.
The default is to allow the record to be logged; any filter can veto
this and the record is then dropped. Returns a zero value if a record
is to be dropped, else non-zero.
.. versionchanged:: 3.2
Allow filters to be just callables.
| def filter(self, record):
"""
Determine if a record is loggable by consulting all the filters.
The default is to allow the record to be logged; any filter can veto
this and the record is then dropped. Returns a zero value if a record
is to be dropped, else non-zero.
.. versionchanged:: 3.2
Allow filters to be just callables.
"""
rv = True
for f in self.filters:
if hasattr(f, 'filter'):
result = f.filter(record)
else:
result = f(record) # assume callable - will raise if not
if not result:
rv = False
break
return rv
| (self, record) |
5,735 | logging | flush |
Ensure all logging output has been flushed.
This version does nothing and is intended to be implemented by
subclasses.
| def flush(self):
"""
Ensure all logging output has been flushed.
This version does nothing and is intended to be implemented by
subclasses.
"""
pass
| (self) |
5,736 | logging | format |
Format the specified record.
If a formatter is set, use it. Otherwise, use the default formatter
for the module.
| def format(self, record):
"""
Format the specified record.
If a formatter is set, use it. Otherwise, use the default formatter
for the module.
"""
if self.formatter:
fmt = self.formatter
else:
fmt = _defaultFormatter
return fmt.format(record)
| (self, record) |
5,737 | logging | get_name | null | def get_name(self):
return self._name
| (self) |
5,738 | logging | handle | Stub. | def handle(self, record):
"""Stub."""
| (self, record) |
5,739 | logging | handleError |
Handle errors which occur during an emit() call.
This method should be called from handlers when an exception is
encountered during an emit() call. If raiseExceptions is false,
exceptions get silently ignored. This is what is mostly wanted
for a logging system - most users will not care about errors in
the logging system, they are more interested in application errors.
You could, however, replace this with a custom handler if you wish.
The record which was being processed is passed in to this method.
| def handleError(self, record):
"""
Handle errors which occur during an emit() call.
This method should be called from handlers when an exception is
encountered during an emit() call. If raiseExceptions is false,
exceptions get silently ignored. This is what is mostly wanted
for a logging system - most users will not care about errors in
the logging system, they are more interested in application errors.
You could, however, replace this with a custom handler if you wish.
The record which was being processed is passed in to this method.
"""
if raiseExceptions and sys.stderr: # see issue 13807
t, v, tb = sys.exc_info()
try:
sys.stderr.write('--- Logging error ---\n')
traceback.print_exception(t, v, tb, None, sys.stderr)
sys.stderr.write('Call stack:\n')
# Walk the stack frame up until we're out of logging,
# so as to print the calling context.
frame = tb.tb_frame
while (frame and os.path.dirname(frame.f_code.co_filename) ==
__path__[0]):
frame = frame.f_back
if frame:
traceback.print_stack(frame, file=sys.stderr)
else:
# couldn't find the right stack frame, for some reason
sys.stderr.write('Logged from file %s, line %s\n' % (
record.filename, record.lineno))
# Issue 18671: output logging message and arguments
try:
sys.stderr.write('Message: %r\n'
'Arguments: %s\n' % (record.msg,
record.args))
except RecursionError: # See issue 36272
raise
except Exception:
sys.stderr.write('Unable to print the message and arguments'
' - possible formatting error.\nUse the'
' traceback above to help find the error.\n'
)
except OSError: #pragma: no cover
pass # see issue 5971
finally:
del t, v, tb
| (self, record) |
5,740 | logging | release |
Release the I/O thread lock.
| def release(self):
"""
Release the I/O thread lock.
"""
if self.lock:
self.lock.release()
| (self) |
5,741 | logging | removeFilter |
Remove the specified filter from this handler.
| def removeFilter(self, filter):
"""
Remove the specified filter from this handler.
"""
if filter in self.filters:
self.filters.remove(filter)
| (self, filter) |
5,742 | logging | setFormatter |
Set the formatter for this handler.
| def setFormatter(self, fmt):
"""
Set the formatter for this handler.
"""
self.formatter = fmt
| (self, fmt) |
5,743 | logging | setLevel |
Set the logging level of this handler. level must be an int or a str.
| def setLevel(self, level):
"""
Set the logging level of this handler. level must be an int or a str.
"""
self.level = _checkLevel(level)
| (self, level) |
5,744 | logging | set_name | null | def set_name(self, name):
_acquireLock()
try:
if self._name in _handlers:
del _handlers[self._name]
self._name = name
if name:
_handlers[name] = self
finally:
_releaseLock()
| (self, name) |
5,758 | simplefix.message | FixMessage | FIX protocol message.
FIX messages consist of an ordered list of tag=value pairs. Tags
are numbers, represented on the wire as strings. Values may have
various types, again all presented as strings on the wire.
This class stores a FIX message: it does not perform any validation
of the content of tags or values, nor the presence of tags required
for compliance with a specific FIX protocol version.
| class FixMessage:
"""FIX protocol message.
FIX messages consist of an ordered list of tag=value pairs. Tags
are numbers, represented on the wire as strings. Values may have
various types, again all presented as strings on the wire.
This class stores a FIX message: it does not perform any validation
of the content of tags or values, nor the presence of tags required
for compliance with a specific FIX protocol version.
"""
def __init__(self):
"""Initialise a FIX message."""
self.begin_string = None
self.message_type = None
self.pairs = []
self.header_index = 0
def count(self):
"""Return the number of pairs in this message."""
return len(self.pairs)
def append_pair(self, tag, value, header=False):
"""Append a tag=value pair to this message.
:param tag: Integer or string FIX tag number.
:param value: FIX tag value.
:param header: Append to header if True; default to body.
Both parameters are explicitly converted to strings before
storage, so it's ok to pass integers if that's easier for
your program logic.
Note: a Python 'None' value will be silently ignored, and
no field is appended.
"""
if tag is None or value is None:
return
if int(tag) == 8:
self.begin_string = fix_val(value)
if int(tag) == 35:
self.message_type = fix_val(value)
if header:
self.pairs.insert(self.header_index,
(fix_tag(tag),
fix_val(value)))
self.header_index += 1
else:
self.pairs.append((fix_tag(tag), fix_val(value)))
def append_time(self, tag, timestamp=None, precision=3, utc=True,
header=False):
"""Append a time field to this message.
:param tag: Integer or string FIX tag number.
:param timestamp: Time (see below) value to append, or None for now.
:param precision: Number of decimal digits. Zero for seconds only,
three for milliseconds, 6 for microseconds. Defaults to milliseconds.
:param utc: Use UTC if True, local time if False.
:param header: Append to header if True; default to body.
THIS METHOD IS DEPRECATED!
USE append_utc_timestamp() OR append_tz_timestamp() INSTEAD.
Append a timestamp in FIX format from a Python time.time or
datetime.datetime value.
Note that prior to FIX 5.0, precision must be zero or three to be
compliant with the standard.
"""
warnings.warn("simplefix.FixMessage.append_time() is deprecated. "
"Use append_utc_timestamp() or append_tz_timestamp() "
"instead.", DeprecationWarning)
if not timestamp:
t = datetime.datetime.utcnow()
elif type(timestamp) is float:
if utc:
t = datetime.datetime.utcfromtimestamp(timestamp)
else:
t = datetime.datetime.fromtimestamp(timestamp)
else:
t = timestamp
s = f"{t:%Y%m%d-%H:%M:%S}"
if precision == 3:
s += f".{t.microsecond // 1000:03d}"
elif precision == 6:
s += f".{t.microsecond:06d}"
elif precision != 0:
raise ValueError("Precision should be one of 0, 3 or 6 digits")
return self.append_pair(tag, s, header=header)
def _append_utc_datetime(self, tag, fmt, ts, precision, header):
"""(Internal) Append formatted datetime."""
if ts is None:
t = datetime.datetime.utcnow()
elif type(ts) is float:
t = datetime.datetime.utcfromtimestamp(ts)
else:
t = ts
if precision == 0:
s = t.strftime(fmt)
elif precision == 3:
s = f"{t.strftime(fmt)}.{t.microsecond // 1000:03d}"
elif precision == 6:
s = f"{t.strftime(fmt)}.{t.microsecond:06d}"
else:
raise ValueError("Precision should be one of 0, 3 or 6 digits")
return self.append_pair(tag, s, header=header)
def append_utc_timestamp(self, tag, timestamp=None, precision=3,
header=False):
"""Append a field with a UTCTimestamp value.
:param tag: Integer or string FIX tag number.
:param timestamp: Time value, see below.
:param precision: Number of decimal places: 0, 3 (ms) or 6 (us).
:param header: Append to FIX header if True; default to body.
The `timestamp` value should be a datetime, such as created by
datetime.datetime.utcnow(); a float, being the number of seconds
since midnight 1 Jan 1970 UTC, such as returned by time.time();
or, None, in which case datetime.datetime.utcnow() is used to
get the current UTC time.
Precision values other than zero (seconds), 3 (milliseconds),
or 6 (microseconds) will raise an exception. Note that prior
to FIX 5.0, only values of 0 or 3 comply with the standard.
"""
return self._append_utc_datetime(tag,
"%Y%m%d-%H:%M:%S",
timestamp,
precision,
header)
def append_utc_time_only(self, tag, timestamp=None, precision=3,
header=False):
"""Append a field with a UTCTimeOnly value.
:param tag: Integer or string FIX tag number.
:param timestamp: Time value, see below.
:param precision: Number of decimal places: 0, 3 (ms) or 6 (us).
:param header: Append to FIX header if True; default to body.
The `timestamp` value should be a datetime, such as created by
datetime.datetime.utcnow(); a float, being the number of seconds
since midnight 1 Jan 1970 UTC, such as returned by time.time();
or, None, in which case datetime.datetime.utcnow() is used to
get the current UTC time.
Precision values other than zero (seconds), 3 (milliseconds),
or 6 (microseconds) will raise an exception. Note that prior
to FIX 5.0, only values of 0 or 3 comply with the standard.
"""
return self._append_utc_datetime(tag,
"%H:%M:%S",
timestamp,
precision,
header)
def append_utc_time_only_parts(self, tag, h, m, s, ms=None, us=None,
header=False):
"""Append a field with a UTCTimeOnly value from components.
:param tag: Integer or string FIX tag number.
:param h: Hours, in range 0 to 23.
:param m: Minutes, in range 0 to 59.
:param s: Seconds, in range 0 to 59 (60 for leap second).
:param ms: Optional milliseconds, in range 0 to 999.
:param us: Optional microseconds, in range 0 to 999.
:param header: Append to FIX header if True; default to body.
Formats the UTCTimeOnly value from its components.
If `ms` or `us` are None, the precision is truncated at
that point. Note that seconds are not optional, unlike in
TZTimeOnly.
"""
ih = int(h)
if ih < 0 or ih > 23:
raise ValueError(f"Hour value `h` ({ih}) out of range 0 to 23")
im = int(m)
if im < 0 or im > 59:
raise ValueError(f"Minute value `m` ({im}) out of range 0 to 59")
isec = int(s)
if isec < 0 or isec > 60:
raise ValueError(f"Seconds value `s` ({isec}) out of range 0 to 60")
v = f"{ih:02d}:{im:02d}:{isec:02d}"
if ms is not None:
ims = int(ms)
if ims < 0 or ims > 999:
raise ValueError(
f"Milliseconds value `ms` ({ims}) out of range 0 to 999")
v += f".{ims:03d}"
if us is not None:
ius = int(us)
if ius < 0 or ius > 999:
raise ValueError(
f"Microseconds value `us` ({ius}) out of range 0 to 999")
v += f"{ius:03d}"
return self.append_pair(tag, v, header=header)
def append_tz_timestamp(self, tag, timestamp=None, precision=3,
header=False):
"""Append a field with a TZTimestamp value, derived from local time.
:param tag: Integer or string FIX tag number.
:param timestamp: Time value, see below.
:param precision: Number of decimal places: 0, 3 (ms) or 6 (us).
:param header: Append to FIX header if True; default to body.
The `timestamp` value should be a local datetime, such as created
by datetime.datetime.now(); a float, being the number of seconds
since midnight 1 Jan 1970 UTC, such as returned by time.time();
or, None, in which case datetime.datetime.now() is used to get
the current local time.
Precision values other than zero (seconds), 3 (milliseconds),
or 6 (microseconds) will raise an exception. Note that prior
to FIX 5.0, only values of 0 or 3 comply with the standard.
"""
# Get float offset from Unix epoch.
if timestamp is None:
now = time.time()
elif type(timestamp) is float:
now = timestamp
else:
now = time.mktime(timestamp.timetuple()) + \
(timestamp.microsecond * 1e-6)
# Get offset of local timezone east of UTC.
utc = datetime.datetime.utcfromtimestamp(now)
local = datetime.datetime.fromtimestamp(now)
td = local - utc
offset = int(((td.days * 86400) + td.seconds) / 60)
fmt = "%Y%m%d-%H:%M:%S"
if precision == 0:
s = local.strftime(fmt)
elif precision == 3:
s = f"{local.strftime(fmt)}.{local.microsecond // 1000:03d}"
elif precision == 6:
s = f"{local.strftime(fmt)}.{local.microsecond:06d}"
else:
raise ValueError(
f"Precision ({precision}) should be one of 0, 3 or 6 digits")
s += self._tz_offset_string(offset)
return self.append_pair(tag, s, header=header)
def append_tz_time_only(self, tag, timestamp=None, precision=3,
header=False):
"""Append a field with a TZTimeOnly value.
:param tag: Integer or string FIX tag number.
:param timestamp: Time value, see below.
:param precision: Number of decimal places: 0, 3 (ms) or 6 (us).
:param header: Append to FIX header if True; default to body.
The `timestamp` value should be a local datetime, such as created
by datetime.datetime.now(); a float, being the number of seconds
since midnight 1 Jan 1970 UTC, such as returned by time.time();
or, None, in which case datetime.datetime.now() is used to
get the current UTC time.
Precision values other than None (minutes), zero (seconds),
3 (milliseconds), or 6 (microseconds) will raise an exception.
Note that prior to FIX 5.0, only values of 0 or 3 comply with the
standard.
"""
if timestamp is None:
t = datetime.datetime.now()
elif type(timestamp) is float:
t = datetime.datetime.fromtimestamp(timestamp)
else:
t = timestamp
now = time.mktime(t.timetuple()) + (t.microsecond * 1e-6)
utc = datetime.datetime.utcfromtimestamp(now)
td = t - utc
offset = int(((td.days * 86400) + td.seconds) / 60)
if precision is None:
s = f"{t:%H:%M}"
elif precision == 0:
s = f"{t:%H:%M:%S}"
elif precision == 3:
s = f"{t:%H:%M:%S}.{t.microsecond // 1000:03d}"
elif precision == 6:
s = f"{t:%H:%M:%S}.{t.microsecond:06d}"
else:
raise ValueError(
"Precision should be one of None, 0, 3 or 6 digits")
s += self._tz_offset_string(offset)
return self.append_pair(tag, s, header=header)
def append_tz_time_only_parts(self, tag, h, m, s=None, ms=None, us=None,
offset=0, header=False):
"""Append a field with a TZTimeOnly value from components.
:param tag: Integer or string FIX tag number.
:param h: Hours, in range 0 to 23.
:param m: Minutes, in range 0 to 59.
:param s: Optional seconds, in range 0 to 59 (60 for leap second).
:param ms: Optional milliseconds, in range 0 to 999.
:param us: Optional microseconds, in range 0 to 999.
:param offset: Minutes east of UTC, in range -1439 to +1439.
:param header: Append to FIX header if True; default to body.
Formats the TZTimeOnly value from its components.
If `s`, `ms` or `us` are None, the precision is truncated at
that point.
"""
ih = int(h)
if ih < 0 or ih > 23:
raise ValueError(f"Hour value `h` ({ih}) out of range 0 to 23")
im = int(m)
if im < 0 or im > 59:
raise ValueError(f"Minute value `m` ({im}) out of range 0 to 59")
v = "%02u:%02u" % (ih, im)
if s is not None:
isec = int(s)
if isec < 0 or isec > 60:
raise ValueError(f"Seconds value `s` ({isec}) "
"out of range 0 to 60")
v += f":{isec:02d}"
if ms is not None:
ims = int(ms)
if ims < 0 or ims > 999:
raise ValueError(f"Milliseconds value `ms` ({ims}) "
"out of range 0 to 999")
v += f".{ims:03d}"
if us is not None:
ius = int(us)
if ius < 0 or ius > 999:
raise ValueError(f"Microseconds value `us` ({ius}) "
"out of range 0 to 999")
v += f"{ius:03d}"
v += self._tz_offset_string(offset)
return self.append_pair(tag, v, header=header)
def append_string(self, field, header=False):
"""Append a tag=value pair in string format.
:param field: String "tag=value" to be appended to this message.
:param header: Append to header if True; default to body.
The string is split at the first '=' character, and the resulting
tag and value strings are appended to the message.
"""
# Split into tag and value.
bits = field.split('=', 1)
if len(bits) != 2:
raise ValueError("Field missing '=' separator.")
# Check tag is an integer.
try:
tag_int = int(bits[0])
except ValueError:
raise ValueError("Tag value must be an integer")
# Save.
self.append_pair(tag_int, bits[1], header=header)
def append_strings(self, string_list, header=False):
"""Append tag=pairs for each supplied string.
:param string_list: List of "tag=value" strings.
:param header: Append to header if True; default to body.
Each string is split, and the resulting tag and value strings
are appended to the message.
"""
for s in string_list:
self.append_string(s, header=header)
def append_data(self, len_tag, val_tag, data, header=False):
"""Append raw data, possibly including a embedded SOH.
:param len_tag: Tag number for length field.
:param val_tag: Tag number for value field.
:param data: Raw data byte string.
:param header: Append to header if True; default to body.
Appends two pairs: a length pair, followed by a data pair,
containing the raw data supplied. Example fields that should
use this method include: 95/96, 212/213, 354/355, etc.
"""
self.append_pair(len_tag, len(data), header=header)
self.append_pair(val_tag, data, header=header)
def get(self, tag, nth=1):
"""Return n-th value for tag.
:param tag: FIX field tag number.
:param nth: Index of tag if repeating, first is 1.
:return: None if nothing found, otherwise value matching tag.
Defaults to returning the first matching value of 'tag', but if
the 'nth' parameter is overridden, can get repeated fields.
"""
tag = fix_tag(tag)
nth = int(nth)
for t, v in self.pairs:
if t == tag:
nth -= 1
if nth == 0:
return v
return None
def remove(self, tag, nth=1):
"""Remove the n-th occurrence of tag in this message.
:param tag: FIX field tag number to be removed.
:param nth: Index of tag if repeating, first is 1.
:returns: Value of the field if removed, None otherwise.
"""
tag = fix_tag(tag)
nth = int(nth)
for i in range(len(self.pairs)):
t, v = self.pairs[i]
if t == tag:
nth -= 1
if nth == 0:
self.pairs.pop(i)
return v
return None
def encode(self, raw=False):
"""Convert message to on-the-wire FIX format.
:param raw: If True, encode pairs exactly as provided.
Unless 'raw' is set, this function will calculate and
correctly set the BodyLength (9) and Checksum (10) fields, and
ensure that the BeginString (8), Body Length (9), Message Type
(35) and Checksum (10) fields are in the right positions.
This function does no further validation of the message content.
"""
buf = b""
if raw:
# Walk pairs, creating string.
for tag, value in self.pairs:
buf += tag + b'=' + value + SOH_STR
return buf
# Cooked.
for tag, value in self.pairs:
if int(tag) in (8, 9, 35, 10):
continue
buf += tag + b'=' + value + SOH_STR
# Prepend the message type.
if self.message_type is None:
raise ValueError("No message type set")
buf = b"35=" + self.message_type + SOH_STR + buf
# Calculate body length.
#
# From first byte after body length field, to the delimiter
# before the checksum (which shouldn't be there yet).
body_length = len(buf)
# Prepend begin-string and body-length.
if not self.begin_string:
raise ValueError("No begin string set")
buf = b"8=" + self.begin_string + SOH_STR + \
b"9=" + fix_val(f"{body_length}") + SOH_STR + \
buf
# Calculate and append the checksum.
checksum = 0
for c in buf:
checksum += c
buf += b"10=" + fix_val(f"{checksum % 256:03}") + SOH_STR
return buf
def __str__(self):
"""Return string form of message contents."""
return self.to_string('|')
def to_string(self, separator: str = '|') -> str:
"""Return string form of message.
:param separator: Field separator, defaults to '|'.
:returns: String representation of this FIX message.
Note that the output from this function is NOT a legal
FIX message (see encode() for that): this is for logging
or other human-oriented consumption."""
s = ""
for tag, value in self.pairs:
if s:
s += separator
s += tag.decode("ascii") + "=" + value.decode("ascii")
return s
def __eq__(self, other):
"""Compare with another FixMessage.
:param other: Message to compare.
Compares the tag=value pairs, message_type and FIX version
of this message against the `other`.
"""
if not hasattr(other, "pairs"):
return False
# Check pairs list lengths.
if len(self.pairs) != len(other.pairs):
return False
# Clone our pairs list.
tmp = []
for pair in self.pairs:
tmp.append((pair[0], pair[1]))
for pair in other.pairs:
try:
tmp.remove(pair)
except ValueError:
return False
return True
def __ne__(self, other):
"""Inverse compare with another FixMessage.
:param other: Message to compare.
Compares the tag=value pairs, message_type and FIX version
of this message against the `other`.
"""
return not self == other
# Disable hashing, since FixMessage is mutable.
__hash__ = None
def __getitem__(self, item_index):
"""Enable messages to be iterated over, and treated as a sequence.
:param item_index: Numeric index in range 0 to length - 1
Supports both 'for tag, value in message' usage, and
'message[n]' access.
"""
if item_index >= len(self.pairs):
raise IndexError
tag, value = self.pairs[item_index]
return int(tag), value
def __contains__(self, item):
"""Directly support 'in' and 'not in' operators.
:param item: Tag value to check.
"""
needle = fix_tag(item)
for tag, _ in self.pairs:
if tag == needle:
return True
return False
@staticmethod
def _tz_offset_string(offset):
"""(Internal) Convert TZ offset in minutes east to string.
:param offset: Offset in minutes east (-1439 to +1439).
"""
io = int(offset)
if io == 0:
return 'Z'
if io < -1439 or io > 1439:
raise ValueError(f"Timezone `offset` ({io}) out of "
"allowed range -1439 to +1439 minutes")
m = abs(io) % 60
if m == 0:
return f'{int(io / 60):0=+3d}'
else:
return f'{int(io / 60):0=+3d}:{m:0=2d}'
| () |
5,759 | simplefix.message | __contains__ | Directly support 'in' and 'not in' operators.
:param item: Tag value to check.
| def __contains__(self, item):
"""Directly support 'in' and 'not in' operators.
:param item: Tag value to check.
"""
needle = fix_tag(item)
for tag, _ in self.pairs:
if tag == needle:
return True
return False
| (self, item) |
5,760 | simplefix.message | __eq__ | Compare with another FixMessage.
:param other: Message to compare.
Compares the tag=value pairs, message_type and FIX version
of this message against the `other`.
| def __eq__(self, other):
"""Compare with another FixMessage.
:param other: Message to compare.
Compares the tag=value pairs, message_type and FIX version
of this message against the `other`.
"""
if not hasattr(other, "pairs"):
return False
# Check pairs list lengths.
if len(self.pairs) != len(other.pairs):
return False
# Clone our pairs list.
tmp = []
for pair in self.pairs:
tmp.append((pair[0], pair[1]))
for pair in other.pairs:
try:
tmp.remove(pair)
except ValueError:
return False
return True
| (self, other) |
5,761 | simplefix.message | __getitem__ | Enable messages to be iterated over, and treated as a sequence.
:param item_index: Numeric index in range 0 to length - 1
Supports both 'for tag, value in message' usage, and
'message[n]' access.
| def __getitem__(self, item_index):
"""Enable messages to be iterated over, and treated as a sequence.
:param item_index: Numeric index in range 0 to length - 1
Supports both 'for tag, value in message' usage, and
'message[n]' access.
"""
if item_index >= len(self.pairs):
raise IndexError
tag, value = self.pairs[item_index]
return int(tag), value
| (self, item_index) |
5,762 | simplefix.message | __init__ | Initialise a FIX message. | def __init__(self):
"""Initialise a FIX message."""
self.begin_string = None
self.message_type = None
self.pairs = []
self.header_index = 0
| (self) |
5,763 | simplefix.message | __ne__ | Inverse compare with another FixMessage.
:param other: Message to compare.
Compares the tag=value pairs, message_type and FIX version
of this message against the `other`.
| def __ne__(self, other):
"""Inverse compare with another FixMessage.
:param other: Message to compare.
Compares the tag=value pairs, message_type and FIX version
of this message against the `other`.
"""
return not self == other
| (self, other) |
5,764 | simplefix.message | __str__ | Return string form of message contents. | def __str__(self):
"""Return string form of message contents."""
return self.to_string('|')
| (self) |
5,765 | simplefix.message | _append_utc_datetime | (Internal) Append formatted datetime. | def _append_utc_datetime(self, tag, fmt, ts, precision, header):
"""(Internal) Append formatted datetime."""
if ts is None:
t = datetime.datetime.utcnow()
elif type(ts) is float:
t = datetime.datetime.utcfromtimestamp(ts)
else:
t = ts
if precision == 0:
s = t.strftime(fmt)
elif precision == 3:
s = f"{t.strftime(fmt)}.{t.microsecond // 1000:03d}"
elif precision == 6:
s = f"{t.strftime(fmt)}.{t.microsecond:06d}"
else:
raise ValueError("Precision should be one of 0, 3 or 6 digits")
return self.append_pair(tag, s, header=header)
| (self, tag, fmt, ts, precision, header) |
5,766 | simplefix.message | _tz_offset_string | (Internal) Convert TZ offset in minutes east to string.
:param offset: Offset in minutes east (-1439 to +1439).
| @staticmethod
def _tz_offset_string(offset):
"""(Internal) Convert TZ offset in minutes east to string.
:param offset: Offset in minutes east (-1439 to +1439).
"""
io = int(offset)
if io == 0:
return 'Z'
if io < -1439 or io > 1439:
raise ValueError(f"Timezone `offset` ({io}) out of "
"allowed range -1439 to +1439 minutes")
m = abs(io) % 60
if m == 0:
return f'{int(io / 60):0=+3d}'
else:
return f'{int(io / 60):0=+3d}:{m:0=2d}'
| (offset) |
5,767 | simplefix.message | append_data | Append raw data, possibly including a embedded SOH.
:param len_tag: Tag number for length field.
:param val_tag: Tag number for value field.
:param data: Raw data byte string.
:param header: Append to header if True; default to body.
Appends two pairs: a length pair, followed by a data pair,
containing the raw data supplied. Example fields that should
use this method include: 95/96, 212/213, 354/355, etc.
| def append_data(self, len_tag, val_tag, data, header=False):
"""Append raw data, possibly including a embedded SOH.
:param len_tag: Tag number for length field.
:param val_tag: Tag number for value field.
:param data: Raw data byte string.
:param header: Append to header if True; default to body.
Appends two pairs: a length pair, followed by a data pair,
containing the raw data supplied. Example fields that should
use this method include: 95/96, 212/213, 354/355, etc.
"""
self.append_pair(len_tag, len(data), header=header)
self.append_pair(val_tag, data, header=header)
| (self, len_tag, val_tag, data, header=False) |
5,768 | simplefix.message | append_pair | Append a tag=value pair to this message.
:param tag: Integer or string FIX tag number.
:param value: FIX tag value.
:param header: Append to header if True; default to body.
Both parameters are explicitly converted to strings before
storage, so it's ok to pass integers if that's easier for
your program logic.
Note: a Python 'None' value will be silently ignored, and
no field is appended.
| def append_pair(self, tag, value, header=False):
"""Append a tag=value pair to this message.
:param tag: Integer or string FIX tag number.
:param value: FIX tag value.
:param header: Append to header if True; default to body.
Both parameters are explicitly converted to strings before
storage, so it's ok to pass integers if that's easier for
your program logic.
Note: a Python 'None' value will be silently ignored, and
no field is appended.
"""
if tag is None or value is None:
return
if int(tag) == 8:
self.begin_string = fix_val(value)
if int(tag) == 35:
self.message_type = fix_val(value)
if header:
self.pairs.insert(self.header_index,
(fix_tag(tag),
fix_val(value)))
self.header_index += 1
else:
self.pairs.append((fix_tag(tag), fix_val(value)))
| (self, tag, value, header=False) |
5,769 | simplefix.message | append_string | Append a tag=value pair in string format.
:param field: String "tag=value" to be appended to this message.
:param header: Append to header if True; default to body.
The string is split at the first '=' character, and the resulting
tag and value strings are appended to the message.
| def append_string(self, field, header=False):
"""Append a tag=value pair in string format.
:param field: String "tag=value" to be appended to this message.
:param header: Append to header if True; default to body.
The string is split at the first '=' character, and the resulting
tag and value strings are appended to the message.
"""
# Split into tag and value.
bits = field.split('=', 1)
if len(bits) != 2:
raise ValueError("Field missing '=' separator.")
# Check tag is an integer.
try:
tag_int = int(bits[0])
except ValueError:
raise ValueError("Tag value must be an integer")
# Save.
self.append_pair(tag_int, bits[1], header=header)
| (self, field, header=False) |
5,770 | simplefix.message | append_strings | Append tag=pairs for each supplied string.
:param string_list: List of "tag=value" strings.
:param header: Append to header if True; default to body.
Each string is split, and the resulting tag and value strings
are appended to the message.
| def append_strings(self, string_list, header=False):
"""Append tag=pairs for each supplied string.
:param string_list: List of "tag=value" strings.
:param header: Append to header if True; default to body.
Each string is split, and the resulting tag and value strings
are appended to the message.
"""
for s in string_list:
self.append_string(s, header=header)
| (self, string_list, header=False) |
5,771 | simplefix.message | append_time | Append a time field to this message.
:param tag: Integer or string FIX tag number.
:param timestamp: Time (see below) value to append, or None for now.
:param precision: Number of decimal digits. Zero for seconds only,
three for milliseconds, 6 for microseconds. Defaults to milliseconds.
:param utc: Use UTC if True, local time if False.
:param header: Append to header if True; default to body.
THIS METHOD IS DEPRECATED!
USE append_utc_timestamp() OR append_tz_timestamp() INSTEAD.
Append a timestamp in FIX format from a Python time.time or
datetime.datetime value.
Note that prior to FIX 5.0, precision must be zero or three to be
compliant with the standard.
| def append_time(self, tag, timestamp=None, precision=3, utc=True,
header=False):
"""Append a time field to this message.
:param tag: Integer or string FIX tag number.
:param timestamp: Time (see below) value to append, or None for now.
:param precision: Number of decimal digits. Zero for seconds only,
three for milliseconds, 6 for microseconds. Defaults to milliseconds.
:param utc: Use UTC if True, local time if False.
:param header: Append to header if True; default to body.
THIS METHOD IS DEPRECATED!
USE append_utc_timestamp() OR append_tz_timestamp() INSTEAD.
Append a timestamp in FIX format from a Python time.time or
datetime.datetime value.
Note that prior to FIX 5.0, precision must be zero or three to be
compliant with the standard.
"""
warnings.warn("simplefix.FixMessage.append_time() is deprecated. "
"Use append_utc_timestamp() or append_tz_timestamp() "
"instead.", DeprecationWarning)
if not timestamp:
t = datetime.datetime.utcnow()
elif type(timestamp) is float:
if utc:
t = datetime.datetime.utcfromtimestamp(timestamp)
else:
t = datetime.datetime.fromtimestamp(timestamp)
else:
t = timestamp
s = f"{t:%Y%m%d-%H:%M:%S}"
if precision == 3:
s += f".{t.microsecond // 1000:03d}"
elif precision == 6:
s += f".{t.microsecond:06d}"
elif precision != 0:
raise ValueError("Precision should be one of 0, 3 or 6 digits")
return self.append_pair(tag, s, header=header)
| (self, tag, timestamp=None, precision=3, utc=True, header=False) |
5,772 | simplefix.message | append_tz_time_only | Append a field with a TZTimeOnly value.
:param tag: Integer or string FIX tag number.
:param timestamp: Time value, see below.
:param precision: Number of decimal places: 0, 3 (ms) or 6 (us).
:param header: Append to FIX header if True; default to body.
The `timestamp` value should be a local datetime, such as created
by datetime.datetime.now(); a float, being the number of seconds
since midnight 1 Jan 1970 UTC, such as returned by time.time();
or, None, in which case datetime.datetime.now() is used to
get the current UTC time.
Precision values other than None (minutes), zero (seconds),
3 (milliseconds), or 6 (microseconds) will raise an exception.
Note that prior to FIX 5.0, only values of 0 or 3 comply with the
standard.
| def append_tz_time_only(self, tag, timestamp=None, precision=3,
header=False):
"""Append a field with a TZTimeOnly value.
:param tag: Integer or string FIX tag number.
:param timestamp: Time value, see below.
:param precision: Number of decimal places: 0, 3 (ms) or 6 (us).
:param header: Append to FIX header if True; default to body.
The `timestamp` value should be a local datetime, such as created
by datetime.datetime.now(); a float, being the number of seconds
since midnight 1 Jan 1970 UTC, such as returned by time.time();
or, None, in which case datetime.datetime.now() is used to
get the current UTC time.
Precision values other than None (minutes), zero (seconds),
3 (milliseconds), or 6 (microseconds) will raise an exception.
Note that prior to FIX 5.0, only values of 0 or 3 comply with the
standard.
"""
if timestamp is None:
t = datetime.datetime.now()
elif type(timestamp) is float:
t = datetime.datetime.fromtimestamp(timestamp)
else:
t = timestamp
now = time.mktime(t.timetuple()) + (t.microsecond * 1e-6)
utc = datetime.datetime.utcfromtimestamp(now)
td = t - utc
offset = int(((td.days * 86400) + td.seconds) / 60)
if precision is None:
s = f"{t:%H:%M}"
elif precision == 0:
s = f"{t:%H:%M:%S}"
elif precision == 3:
s = f"{t:%H:%M:%S}.{t.microsecond // 1000:03d}"
elif precision == 6:
s = f"{t:%H:%M:%S}.{t.microsecond:06d}"
else:
raise ValueError(
"Precision should be one of None, 0, 3 or 6 digits")
s += self._tz_offset_string(offset)
return self.append_pair(tag, s, header=header)
| (self, tag, timestamp=None, precision=3, header=False) |
5,773 | simplefix.message | append_tz_time_only_parts | Append a field with a TZTimeOnly value from components.
:param tag: Integer or string FIX tag number.
:param h: Hours, in range 0 to 23.
:param m: Minutes, in range 0 to 59.
:param s: Optional seconds, in range 0 to 59 (60 for leap second).
:param ms: Optional milliseconds, in range 0 to 999.
:param us: Optional microseconds, in range 0 to 999.
:param offset: Minutes east of UTC, in range -1439 to +1439.
:param header: Append to FIX header if True; default to body.
Formats the TZTimeOnly value from its components.
If `s`, `ms` or `us` are None, the precision is truncated at
that point.
| def append_tz_time_only_parts(self, tag, h, m, s=None, ms=None, us=None,
offset=0, header=False):
"""Append a field with a TZTimeOnly value from components.
:param tag: Integer or string FIX tag number.
:param h: Hours, in range 0 to 23.
:param m: Minutes, in range 0 to 59.
:param s: Optional seconds, in range 0 to 59 (60 for leap second).
:param ms: Optional milliseconds, in range 0 to 999.
:param us: Optional microseconds, in range 0 to 999.
:param offset: Minutes east of UTC, in range -1439 to +1439.
:param header: Append to FIX header if True; default to body.
Formats the TZTimeOnly value from its components.
If `s`, `ms` or `us` are None, the precision is truncated at
that point.
"""
ih = int(h)
if ih < 0 or ih > 23:
raise ValueError(f"Hour value `h` ({ih}) out of range 0 to 23")
im = int(m)
if im < 0 or im > 59:
raise ValueError(f"Minute value `m` ({im}) out of range 0 to 59")
v = "%02u:%02u" % (ih, im)
if s is not None:
isec = int(s)
if isec < 0 or isec > 60:
raise ValueError(f"Seconds value `s` ({isec}) "
"out of range 0 to 60")
v += f":{isec:02d}"
if ms is not None:
ims = int(ms)
if ims < 0 or ims > 999:
raise ValueError(f"Milliseconds value `ms` ({ims}) "
"out of range 0 to 999")
v += f".{ims:03d}"
if us is not None:
ius = int(us)
if ius < 0 or ius > 999:
raise ValueError(f"Microseconds value `us` ({ius}) "
"out of range 0 to 999")
v += f"{ius:03d}"
v += self._tz_offset_string(offset)
return self.append_pair(tag, v, header=header)
| (self, tag, h, m, s=None, ms=None, us=None, offset=0, header=False) |
5,774 | simplefix.message | append_tz_timestamp | Append a field with a TZTimestamp value, derived from local time.
:param tag: Integer or string FIX tag number.
:param timestamp: Time value, see below.
:param precision: Number of decimal places: 0, 3 (ms) or 6 (us).
:param header: Append to FIX header if True; default to body.
The `timestamp` value should be a local datetime, such as created
by datetime.datetime.now(); a float, being the number of seconds
since midnight 1 Jan 1970 UTC, such as returned by time.time();
or, None, in which case datetime.datetime.now() is used to get
the current local time.
Precision values other than zero (seconds), 3 (milliseconds),
or 6 (microseconds) will raise an exception. Note that prior
to FIX 5.0, only values of 0 or 3 comply with the standard.
| def append_tz_timestamp(self, tag, timestamp=None, precision=3,
header=False):
"""Append a field with a TZTimestamp value, derived from local time.
:param tag: Integer or string FIX tag number.
:param timestamp: Time value, see below.
:param precision: Number of decimal places: 0, 3 (ms) or 6 (us).
:param header: Append to FIX header if True; default to body.
The `timestamp` value should be a local datetime, such as created
by datetime.datetime.now(); a float, being the number of seconds
since midnight 1 Jan 1970 UTC, such as returned by time.time();
or, None, in which case datetime.datetime.now() is used to get
the current local time.
Precision values other than zero (seconds), 3 (milliseconds),
or 6 (microseconds) will raise an exception. Note that prior
to FIX 5.0, only values of 0 or 3 comply with the standard.
"""
# Get float offset from Unix epoch.
if timestamp is None:
now = time.time()
elif type(timestamp) is float:
now = timestamp
else:
now = time.mktime(timestamp.timetuple()) + \
(timestamp.microsecond * 1e-6)
# Get offset of local timezone east of UTC.
utc = datetime.datetime.utcfromtimestamp(now)
local = datetime.datetime.fromtimestamp(now)
td = local - utc
offset = int(((td.days * 86400) + td.seconds) / 60)
fmt = "%Y%m%d-%H:%M:%S"
if precision == 0:
s = local.strftime(fmt)
elif precision == 3:
s = f"{local.strftime(fmt)}.{local.microsecond // 1000:03d}"
elif precision == 6:
s = f"{local.strftime(fmt)}.{local.microsecond:06d}"
else:
raise ValueError(
f"Precision ({precision}) should be one of 0, 3 or 6 digits")
s += self._tz_offset_string(offset)
return self.append_pair(tag, s, header=header)
| (self, tag, timestamp=None, precision=3, header=False) |
5,775 | simplefix.message | append_utc_time_only | Append a field with a UTCTimeOnly value.
:param tag: Integer or string FIX tag number.
:param timestamp: Time value, see below.
:param precision: Number of decimal places: 0, 3 (ms) or 6 (us).
:param header: Append to FIX header if True; default to body.
The `timestamp` value should be a datetime, such as created by
datetime.datetime.utcnow(); a float, being the number of seconds
since midnight 1 Jan 1970 UTC, such as returned by time.time();
or, None, in which case datetime.datetime.utcnow() is used to
get the current UTC time.
Precision values other than zero (seconds), 3 (milliseconds),
or 6 (microseconds) will raise an exception. Note that prior
to FIX 5.0, only values of 0 or 3 comply with the standard.
| def append_utc_time_only(self, tag, timestamp=None, precision=3,
header=False):
"""Append a field with a UTCTimeOnly value.
:param tag: Integer or string FIX tag number.
:param timestamp: Time value, see below.
:param precision: Number of decimal places: 0, 3 (ms) or 6 (us).
:param header: Append to FIX header if True; default to body.
The `timestamp` value should be a datetime, such as created by
datetime.datetime.utcnow(); a float, being the number of seconds
since midnight 1 Jan 1970 UTC, such as returned by time.time();
or, None, in which case datetime.datetime.utcnow() is used to
get the current UTC time.
Precision values other than zero (seconds), 3 (milliseconds),
or 6 (microseconds) will raise an exception. Note that prior
to FIX 5.0, only values of 0 or 3 comply with the standard.
"""
return self._append_utc_datetime(tag,
"%H:%M:%S",
timestamp,
precision,
header)
| (self, tag, timestamp=None, precision=3, header=False) |
5,776 | simplefix.message | append_utc_time_only_parts | Append a field with a UTCTimeOnly value from components.
:param tag: Integer or string FIX tag number.
:param h: Hours, in range 0 to 23.
:param m: Minutes, in range 0 to 59.
:param s: Seconds, in range 0 to 59 (60 for leap second).
:param ms: Optional milliseconds, in range 0 to 999.
:param us: Optional microseconds, in range 0 to 999.
:param header: Append to FIX header if True; default to body.
Formats the UTCTimeOnly value from its components.
If `ms` or `us` are None, the precision is truncated at
that point. Note that seconds are not optional, unlike in
TZTimeOnly.
| def append_utc_time_only_parts(self, tag, h, m, s, ms=None, us=None,
header=False):
"""Append a field with a UTCTimeOnly value from components.
:param tag: Integer or string FIX tag number.
:param h: Hours, in range 0 to 23.
:param m: Minutes, in range 0 to 59.
:param s: Seconds, in range 0 to 59 (60 for leap second).
:param ms: Optional milliseconds, in range 0 to 999.
:param us: Optional microseconds, in range 0 to 999.
:param header: Append to FIX header if True; default to body.
Formats the UTCTimeOnly value from its components.
If `ms` or `us` are None, the precision is truncated at
that point. Note that seconds are not optional, unlike in
TZTimeOnly.
"""
ih = int(h)
if ih < 0 or ih > 23:
raise ValueError(f"Hour value `h` ({ih}) out of range 0 to 23")
im = int(m)
if im < 0 or im > 59:
raise ValueError(f"Minute value `m` ({im}) out of range 0 to 59")
isec = int(s)
if isec < 0 or isec > 60:
raise ValueError(f"Seconds value `s` ({isec}) out of range 0 to 60")
v = f"{ih:02d}:{im:02d}:{isec:02d}"
if ms is not None:
ims = int(ms)
if ims < 0 or ims > 999:
raise ValueError(
f"Milliseconds value `ms` ({ims}) out of range 0 to 999")
v += f".{ims:03d}"
if us is not None:
ius = int(us)
if ius < 0 or ius > 999:
raise ValueError(
f"Microseconds value `us` ({ius}) out of range 0 to 999")
v += f"{ius:03d}"
return self.append_pair(tag, v, header=header)
| (self, tag, h, m, s, ms=None, us=None, header=False) |
5,777 | simplefix.message | append_utc_timestamp | Append a field with a UTCTimestamp value.
:param tag: Integer or string FIX tag number.
:param timestamp: Time value, see below.
:param precision: Number of decimal places: 0, 3 (ms) or 6 (us).
:param header: Append to FIX header if True; default to body.
The `timestamp` value should be a datetime, such as created by
datetime.datetime.utcnow(); a float, being the number of seconds
since midnight 1 Jan 1970 UTC, such as returned by time.time();
or, None, in which case datetime.datetime.utcnow() is used to
get the current UTC time.
Precision values other than zero (seconds), 3 (milliseconds),
or 6 (microseconds) will raise an exception. Note that prior
to FIX 5.0, only values of 0 or 3 comply with the standard.
| def append_utc_timestamp(self, tag, timestamp=None, precision=3,
header=False):
"""Append a field with a UTCTimestamp value.
:param tag: Integer or string FIX tag number.
:param timestamp: Time value, see below.
:param precision: Number of decimal places: 0, 3 (ms) or 6 (us).
:param header: Append to FIX header if True; default to body.
The `timestamp` value should be a datetime, such as created by
datetime.datetime.utcnow(); a float, being the number of seconds
since midnight 1 Jan 1970 UTC, such as returned by time.time();
or, None, in which case datetime.datetime.utcnow() is used to
get the current UTC time.
Precision values other than zero (seconds), 3 (milliseconds),
or 6 (microseconds) will raise an exception. Note that prior
to FIX 5.0, only values of 0 or 3 comply with the standard.
"""
return self._append_utc_datetime(tag,
"%Y%m%d-%H:%M:%S",
timestamp,
precision,
header)
| (self, tag, timestamp=None, precision=3, header=False) |
5,778 | simplefix.message | count | Return the number of pairs in this message. | def count(self):
"""Return the number of pairs in this message."""
return len(self.pairs)
| (self) |
5,779 | simplefix.message | encode | Convert message to on-the-wire FIX format.
:param raw: If True, encode pairs exactly as provided.
Unless 'raw' is set, this function will calculate and
correctly set the BodyLength (9) and Checksum (10) fields, and
ensure that the BeginString (8), Body Length (9), Message Type
(35) and Checksum (10) fields are in the right positions.
This function does no further validation of the message content.
| def encode(self, raw=False):
"""Convert message to on-the-wire FIX format.
:param raw: If True, encode pairs exactly as provided.
Unless 'raw' is set, this function will calculate and
correctly set the BodyLength (9) and Checksum (10) fields, and
ensure that the BeginString (8), Body Length (9), Message Type
(35) and Checksum (10) fields are in the right positions.
This function does no further validation of the message content.
"""
buf = b""
if raw:
# Walk pairs, creating string.
for tag, value in self.pairs:
buf += tag + b'=' + value + SOH_STR
return buf
# Cooked.
for tag, value in self.pairs:
if int(tag) in (8, 9, 35, 10):
continue
buf += tag + b'=' + value + SOH_STR
# Prepend the message type.
if self.message_type is None:
raise ValueError("No message type set")
buf = b"35=" + self.message_type + SOH_STR + buf
# Calculate body length.
#
# From first byte after body length field, to the delimiter
# before the checksum (which shouldn't be there yet).
body_length = len(buf)
# Prepend begin-string and body-length.
if not self.begin_string:
raise ValueError("No begin string set")
buf = b"8=" + self.begin_string + SOH_STR + \
b"9=" + fix_val(f"{body_length}") + SOH_STR + \
buf
# Calculate and append the checksum.
checksum = 0
for c in buf:
checksum += c
buf += b"10=" + fix_val(f"{checksum % 256:03}") + SOH_STR
return buf
| (self, raw=False) |
5,780 | simplefix.message | get | Return n-th value for tag.
:param tag: FIX field tag number.
:param nth: Index of tag if repeating, first is 1.
:return: None if nothing found, otherwise value matching tag.
Defaults to returning the first matching value of 'tag', but if
the 'nth' parameter is overridden, can get repeated fields.
| def get(self, tag, nth=1):
"""Return n-th value for tag.
:param tag: FIX field tag number.
:param nth: Index of tag if repeating, first is 1.
:return: None if nothing found, otherwise value matching tag.
Defaults to returning the first matching value of 'tag', but if
the 'nth' parameter is overridden, can get repeated fields.
"""
tag = fix_tag(tag)
nth = int(nth)
for t, v in self.pairs:
if t == tag:
nth -= 1
if nth == 0:
return v
return None
| (self, tag, nth=1) |
5,781 | simplefix.message | remove | Remove the n-th occurrence of tag in this message.
:param tag: FIX field tag number to be removed.
:param nth: Index of tag if repeating, first is 1.
:returns: Value of the field if removed, None otherwise.
| def remove(self, tag, nth=1):
"""Remove the n-th occurrence of tag in this message.
:param tag: FIX field tag number to be removed.
:param nth: Index of tag if repeating, first is 1.
:returns: Value of the field if removed, None otherwise.
"""
tag = fix_tag(tag)
nth = int(nth)
for i in range(len(self.pairs)):
t, v = self.pairs[i]
if t == tag:
nth -= 1
if nth == 0:
self.pairs.pop(i)
return v
return None
| (self, tag, nth=1) |
5,782 | simplefix.message | to_string | Return string form of message.
:param separator: Field separator, defaults to '|'.
:returns: String representation of this FIX message.
Note that the output from this function is NOT a legal
FIX message (see encode() for that): this is for logging
or other human-oriented consumption. | def to_string(self, separator: str = '|') -> str:
"""Return string form of message.
:param separator: Field separator, defaults to '|'.
:returns: String representation of this FIX message.
Note that the output from this function is NOT a legal
FIX message (see encode() for that): this is for logging
or other human-oriented consumption."""
s = ""
for tag, value in self.pairs:
if s:
s += separator
s += tag.decode("ascii") + "=" + value.decode("ascii")
return s
| (self, separator: str = '|') -> str |
5,783 | simplefix.parser | FixParser | FIX protocol message parser.
This class translates FIX application messages in raw (wire)
format into instance of the FixMessage class.
It does not perform any validation of the fields, their presence
or absence in a particular message, the data types of fields, or
the values of enumerations.
It is suitable for streaming processing, accumulating byte data
from a network connection, and returning complete messages as they
are delivered, potentially in multiple fragments.
| class FixParser:
"""FIX protocol message parser.
This class translates FIX application messages in raw (wire)
format into instance of the FixMessage class.
It does not perform any validation of the fields, their presence
or absence in a particular message, the data types of fields, or
the values of enumerations.
It is suitable for streaming processing, accumulating byte data
from a network connection, and returning complete messages as they
are delivered, potentially in multiple fragments.
"""
def __init__(self,
allow_empty_values: bool = False,
allow_missing_begin_string: bool = False,
strip_fields_before_begin_string: bool = True,
stop_tag: int = DEFAULT_STOP_TAG,
stop_byte: Optional[bytes] = None):
"""Constructor.
:param allow_empty_values: If set, an empty field value is
allowed, in violation of the FIX specification which prohibits
this.
:param allow_missing_begin_string: If set, an initial field
other than BeginString (8) is permitted.
:param strip_fields_before_begin_string: If set, tag:value pairs
parsed before the BeginString (8) field are ignored.
:param stop_tag: Tag number for final field in a message. This
setting is overridden by stop_byte.
:param stop_byte: Byte that indicates end of message. Typically
CR or LF. Setting this value overrides stop_tag.
"""
# Copy raw field length tags.
self.raw_len_tags = RAW_LEN_TAGS[:]
# Copy raw field data tags.
self.raw_data_tags = RAW_DATA_TAGS[:]
# Internal buffer used to accumulate message data.
self.buf = b""
# Parsed "tag=value" pairs, removed from the buffer, but not
# yet returned as a message.
self.pairs = []
# Parsed length of data field.
self.raw_len = 0
# Behaviour flags.
# Stop tag (default).
self.stop_tag = stop_tag
# Stop character (optional).
self.stop_byte = ord(stop_byte) if stop_byte is not None else None
# Don't insist on an 8= tag at the start of a message.
self.allow_missing_begin_string = allow_missing_begin_string
# Don't insist that fields have a non zero-length value.
self.allow_empty_values = allow_empty_values
# Discard any parsed fields prior to BeginString (8).
self.strip_fields_before_begin_string = strip_fields_before_begin_string
# Validate settings.
if self.allow_missing_begin_string and \
self.strip_fields_before_begin_string:
raise errors.ParserConfigError(
"Can't set 'allow_missing_begin_string' "
"and 'strip_fields_before_begin_string' "
"simultaneously.")
def set_stop_tag(self, value: int = DEFAULT_STOP_TAG):
"""Set the tag number of the final field in a message.
:param value: Final field tag number.
The default value here is CheckSum (10): the parser recognizes
a 10=xxx field as the end of a message. Note that this value
is overridden if a stop_byte is set.
"""
self.stop_tag = value
def set_stop_byte(self, value: Optional[bytes] = None):
"""Set a byte value that will terminate a message.
:param value: Byte (character) value, usually CR or LF.
If the parser encounters this byte, anywhere in a message, it is
interpreted as the end of that message. This is often used when
multiple messages are recorded in a file, separated by eg. LF.
Note that this will override the stop_tag value.
Setting the stop_byte to None will disable it.
"""
self.stop_byte = ord(value) if value is not None else None
def set_allow_missing_begin_string(self, value=True):
"""If set, the first field of a message must be BeginString (8).
:param value: If True, check first field is begin.
In some cases, especially FIX-encoded stored data, there might
not be a Begin String (8) at the start of each message.
Note this value cannot be True if strip_fields_before_begin_string
is also True.
"""
self.allow_missing_begin_string = value
def set_allow_empty_values(self, value=True):
"""Accept a zero-length value when parsing.
:param value: If False, raise exception for zero-length values
The FIX specification prohibits zero-length values, instead
suggesting that the field be omitted from the message entirely.
Some implementations do allow a zero-length value, and so this
is accepted by default.
If this setting is disabled, a ValueHasZeroLengthError is
raised from get_message() if such a value is encountered.
"""
self.allow_empty_values = value
def set_strip_fields_before_begin_string(self, value: bool = True):
"""Choose whether to discard any fields parsed before 8=FIX.
:param value: If set, discard any fields before the BeginString (8).
Note that this setting cannot be set if a missing BeginString is
also permitted.
"""
self.strip_fields_before_begin_string = value
def set_message_terminator(self, tag=None, char=None):
"""Set the end-of-message detection scheme.
:param tag: FIX tag number of terminating field. Default is 10.
:param char: Alternative, terminating character.
THIS METHOD IS DEPRECATED.
Use set_stop_tag(), set_stop_byte(), or constructor keywords
instead.
By default, messages are terminated by the FIX Checksum (10)
field. This can be changed to use a different tag, or a reserved
character using this function.
Note that only one of 'tag' or 'char' should be set, using a
named parameter.
"""
warnings.warn("simplefix.FixParser.set_message_terminator() is "
"deprecated. Use set_stop_tag(), set_stop_byte(), "
"or constructor keywords instead", DeprecationWarning)
if tag is not None and char is not None:
raise ValueError("Only supply one of 'tag' or 'char'.")
if tag is not None:
self.stop_tag = tag
self.stop_byte = None
else:
self.stop_tag = None
self.stop_byte = ord(char) if char is not None else None
def add_raw(self, length_tag, value_tag):
"""Define the tags used for a private raw data field.
:param length_tag: tag number of length field.
:param value_tag: tag number of value field.
Data fields are not terminated by the SOH character as is usual for
FIX, but instead have a second, preceding field that specifies the
length of the value in bytes. The parser is initialised with all the
data fields defined in FIX.5.0, but if your application uses private
data fields, you can add them here, and the parser will process them
correctly.
"""
self.raw_len_tags.append(length_tag)
self.raw_data_tags.append(value_tag)
def remove_raw(self, length_tag, value_tag):
"""Remove the tags for a data type field.
:param length_tag: tag number of the length field.
:param value_tag: tag number of the value field.
You can remove either private or standard data field definitions in
case a particular application uses them for a field of a different
type.
"""
self.raw_len_tags.remove(length_tag)
self.raw_data_tags.remove(value_tag)
def reset(self):
"""Reset the internal parser state.
This will discard any appended buffer content, and any fields
parsed so far.
"""
self.buf = b""
self.pairs = []
self.raw_len = 0
def append_buffer(self, buf):
"""Append a byte string to the parser buffer.
:param buf: byte string to append.
The parser maintains an internal buffer of bytes to be parsed.
As raw data is read, it can be appended to this buffer. Each
call to get_message() will try to remove the bytes of a
complete messages from the head of the buffer.
"""
self.buf += fix_val(buf)
def get_buffer(self):
"""Return a reference to the internal buffer."""
return self.buf
def get_message(self):
"""Process the accumulated buffer and return the first message.
If the buffer starts with FIX fields other than BeginString
(8), these are discarded until the start of a message is
found.
If no BeginString (8) field is found, this function returns
None. Similarly, if (after a BeginString) no Checksum (10)
field is found, the function returns None.
Otherwise, it returns a simplefix.FixMessage instance
initialised with the fields from the first complete message
found in the buffer.
"""
# Break buffer into tag=value pairs.
start: int = 0
point: int = 0
tag: int = 0
in_tag: bool = True
eom: bool = False
while point < len(self.buf):
b = self.buf[point]
if in_tag:
# Check for end of tag.
if b == EQUALS_BYTE: # skipcq: PYL-R1724
tag_string = self.buf[start:point]
point += 1
try:
tag = int(tag_string)
except ValueError as e:
raise errors.TagNotNumberError(*e.args)
if tag in self.raw_data_tags and self.raw_len > 0:
# Try to extract the data value.
if self.raw_len > len(self.buf) - point:
# The buffer doesn't yet contain all the raw data,
# so wait for more to be added.
break
# We've got enough buffer to extract the raw data value.
value = self.buf[point:point + self.raw_len]
self.buf = self.buf[point + self.raw_len + 1:]
self.raw_len = 0
point = 0
self.pairs.append((tag, value))
# Expect a tag (or EOM) next.
in_tag = True
else:
# After EQUALS_BYTE, expect a value.
in_tag = False
start = point
continue
elif b == self.stop_byte:
if point != 0:
# Stop byte in the middle of a tag.
raise errors.IncompleteTagError(self.buf[:point])
# stop_byte follows field terminator byte.
eom = True
self.buf = self.buf[1:]
break
else: # not in_tag
if b in (SOH_BYTE, self.stop_byte):
value = self.buf[start:point]
if not self.allow_empty_values and len(value) == 0:
raise errors.EmptyValueError(tag)
self.pairs.append((tag, value))
self.buf = self.buf[point + 1:]
# Check for a stop_byte without a preceding end-of-field.
if b == self.stop_byte:
eom = True
break
# Check for end of message tag.
if tag == self.stop_tag:
break
# If this was a raw data length tag, save the length value.
if tag in self.raw_len_tags:
try:
self.raw_len = int(value)
except ValueError as e:
raise errors.RawLengthNotNumberError(*e.args)
# Reset to look for next tag.
point = 0
start = point
in_tag = True
# Loop (point already advanced when truncating the buffer).
continue
# Advance to next byte in the string and loop.
point += 1
# At this point, we have a sequence of pairs parsed from the buffer,
# and have either a) run of of buffer, b) hit the end-of-message
# character, or c) seen the end-of-message tag (and value).
# No pairs, so no message, so just return None.
if len(self.pairs) == 0:
return None
# Strip leading junk pairs.
if self.strip_fields_before_begin_string:
while self.pairs and self.pairs[0][0] != 8:
# Discard pairs until we find the beginning of a message.
self.pairs.pop(0)
if len(self.pairs) == 0:
return None
# Check first pair is FIX BeginString.
if not self.allow_missing_begin_string and self.pairs[0][0] != 8:
raise errors.FieldOrderError()
# If we don't have an explicit end-of-message byte, check
# the last pair has the configured stop_tag, otherwise
# return None and wait for more data.
if not eom and self.pairs[-1][0] != self.stop_tag:
return None
# Extract message.
m = FixMessage()
for tag, value in self.pairs:
m.append_pair(tag, value)
self.pairs = []
return m
| (allow_empty_values: bool = False, allow_missing_begin_string: bool = False, strip_fields_before_begin_string: bool = True, stop_tag: int = 10, stop_byte: Optional[bytes] = None) |
5,784 | simplefix.parser | __init__ | Constructor.
:param allow_empty_values: If set, an empty field value is
allowed, in violation of the FIX specification which prohibits
this.
:param allow_missing_begin_string: If set, an initial field
other than BeginString (8) is permitted.
:param strip_fields_before_begin_string: If set, tag:value pairs
parsed before the BeginString (8) field are ignored.
:param stop_tag: Tag number for final field in a message. This
setting is overridden by stop_byte.
:param stop_byte: Byte that indicates end of message. Typically
CR or LF. Setting this value overrides stop_tag.
| def __init__(self,
allow_empty_values: bool = False,
allow_missing_begin_string: bool = False,
strip_fields_before_begin_string: bool = True,
stop_tag: int = DEFAULT_STOP_TAG,
stop_byte: Optional[bytes] = None):
"""Constructor.
:param allow_empty_values: If set, an empty field value is
allowed, in violation of the FIX specification which prohibits
this.
:param allow_missing_begin_string: If set, an initial field
other than BeginString (8) is permitted.
:param strip_fields_before_begin_string: If set, tag:value pairs
parsed before the BeginString (8) field are ignored.
:param stop_tag: Tag number for final field in a message. This
setting is overridden by stop_byte.
:param stop_byte: Byte that indicates end of message. Typically
CR or LF. Setting this value overrides stop_tag.
"""
# Copy raw field length tags.
self.raw_len_tags = RAW_LEN_TAGS[:]
# Copy raw field data tags.
self.raw_data_tags = RAW_DATA_TAGS[:]
# Internal buffer used to accumulate message data.
self.buf = b""
# Parsed "tag=value" pairs, removed from the buffer, but not
# yet returned as a message.
self.pairs = []
# Parsed length of data field.
self.raw_len = 0
# Behaviour flags.
# Stop tag (default).
self.stop_tag = stop_tag
# Stop character (optional).
self.stop_byte = ord(stop_byte) if stop_byte is not None else None
# Don't insist on an 8= tag at the start of a message.
self.allow_missing_begin_string = allow_missing_begin_string
# Don't insist that fields have a non zero-length value.
self.allow_empty_values = allow_empty_values
# Discard any parsed fields prior to BeginString (8).
self.strip_fields_before_begin_string = strip_fields_before_begin_string
# Validate settings.
if self.allow_missing_begin_string and \
self.strip_fields_before_begin_string:
raise errors.ParserConfigError(
"Can't set 'allow_missing_begin_string' "
"and 'strip_fields_before_begin_string' "
"simultaneously.")
| (self, allow_empty_values: bool = False, allow_missing_begin_string: bool = False, strip_fields_before_begin_string: bool = True, stop_tag: int = 10, stop_byte: Optional[bytes] = None) |
5,785 | simplefix.parser | add_raw | Define the tags used for a private raw data field.
:param length_tag: tag number of length field.
:param value_tag: tag number of value field.
Data fields are not terminated by the SOH character as is usual for
FIX, but instead have a second, preceding field that specifies the
length of the value in bytes. The parser is initialised with all the
data fields defined in FIX.5.0, but if your application uses private
data fields, you can add them here, and the parser will process them
correctly.
| def add_raw(self, length_tag, value_tag):
"""Define the tags used for a private raw data field.
:param length_tag: tag number of length field.
:param value_tag: tag number of value field.
Data fields are not terminated by the SOH character as is usual for
FIX, but instead have a second, preceding field that specifies the
length of the value in bytes. The parser is initialised with all the
data fields defined in FIX.5.0, but if your application uses private
data fields, you can add them here, and the parser will process them
correctly.
"""
self.raw_len_tags.append(length_tag)
self.raw_data_tags.append(value_tag)
| (self, length_tag, value_tag) |
5,786 | simplefix.parser | append_buffer | Append a byte string to the parser buffer.
:param buf: byte string to append.
The parser maintains an internal buffer of bytes to be parsed.
As raw data is read, it can be appended to this buffer. Each
call to get_message() will try to remove the bytes of a
complete messages from the head of the buffer.
| def append_buffer(self, buf):
"""Append a byte string to the parser buffer.
:param buf: byte string to append.
The parser maintains an internal buffer of bytes to be parsed.
As raw data is read, it can be appended to this buffer. Each
call to get_message() will try to remove the bytes of a
complete messages from the head of the buffer.
"""
self.buf += fix_val(buf)
| (self, buf) |
5,787 | simplefix.parser | get_buffer | Return a reference to the internal buffer. | def get_buffer(self):
"""Return a reference to the internal buffer."""
return self.buf
| (self) |
5,788 | simplefix.parser | get_message | Process the accumulated buffer and return the first message.
If the buffer starts with FIX fields other than BeginString
(8), these are discarded until the start of a message is
found.
If no BeginString (8) field is found, this function returns
None. Similarly, if (after a BeginString) no Checksum (10)
field is found, the function returns None.
Otherwise, it returns a simplefix.FixMessage instance
initialised with the fields from the first complete message
found in the buffer.
| def get_message(self):
"""Process the accumulated buffer and return the first message.
If the buffer starts with FIX fields other than BeginString
(8), these are discarded until the start of a message is
found.
If no BeginString (8) field is found, this function returns
None. Similarly, if (after a BeginString) no Checksum (10)
field is found, the function returns None.
Otherwise, it returns a simplefix.FixMessage instance
initialised with the fields from the first complete message
found in the buffer.
"""
# Break buffer into tag=value pairs.
start: int = 0
point: int = 0
tag: int = 0
in_tag: bool = True
eom: bool = False
while point < len(self.buf):
b = self.buf[point]
if in_tag:
# Check for end of tag.
if b == EQUALS_BYTE: # skipcq: PYL-R1724
tag_string = self.buf[start:point]
point += 1
try:
tag = int(tag_string)
except ValueError as e:
raise errors.TagNotNumberError(*e.args)
if tag in self.raw_data_tags and self.raw_len > 0:
# Try to extract the data value.
if self.raw_len > len(self.buf) - point:
# The buffer doesn't yet contain all the raw data,
# so wait for more to be added.
break
# We've got enough buffer to extract the raw data value.
value = self.buf[point:point + self.raw_len]
self.buf = self.buf[point + self.raw_len + 1:]
self.raw_len = 0
point = 0
self.pairs.append((tag, value))
# Expect a tag (or EOM) next.
in_tag = True
else:
# After EQUALS_BYTE, expect a value.
in_tag = False
start = point
continue
elif b == self.stop_byte:
if point != 0:
# Stop byte in the middle of a tag.
raise errors.IncompleteTagError(self.buf[:point])
# stop_byte follows field terminator byte.
eom = True
self.buf = self.buf[1:]
break
else: # not in_tag
if b in (SOH_BYTE, self.stop_byte):
value = self.buf[start:point]
if not self.allow_empty_values and len(value) == 0:
raise errors.EmptyValueError(tag)
self.pairs.append((tag, value))
self.buf = self.buf[point + 1:]
# Check for a stop_byte without a preceding end-of-field.
if b == self.stop_byte:
eom = True
break
# Check for end of message tag.
if tag == self.stop_tag:
break
# If this was a raw data length tag, save the length value.
if tag in self.raw_len_tags:
try:
self.raw_len = int(value)
except ValueError as e:
raise errors.RawLengthNotNumberError(*e.args)
# Reset to look for next tag.
point = 0
start = point
in_tag = True
# Loop (point already advanced when truncating the buffer).
continue
# Advance to next byte in the string and loop.
point += 1
# At this point, we have a sequence of pairs parsed from the buffer,
# and have either a) run of of buffer, b) hit the end-of-message
# character, or c) seen the end-of-message tag (and value).
# No pairs, so no message, so just return None.
if len(self.pairs) == 0:
return None
# Strip leading junk pairs.
if self.strip_fields_before_begin_string:
while self.pairs and self.pairs[0][0] != 8:
# Discard pairs until we find the beginning of a message.
self.pairs.pop(0)
if len(self.pairs) == 0:
return None
# Check first pair is FIX BeginString.
if not self.allow_missing_begin_string and self.pairs[0][0] != 8:
raise errors.FieldOrderError()
# If we don't have an explicit end-of-message byte, check
# the last pair has the configured stop_tag, otherwise
# return None and wait for more data.
if not eom and self.pairs[-1][0] != self.stop_tag:
return None
# Extract message.
m = FixMessage()
for tag, value in self.pairs:
m.append_pair(tag, value)
self.pairs = []
return m
| (self) |
5,789 | simplefix.parser | remove_raw | Remove the tags for a data type field.
:param length_tag: tag number of the length field.
:param value_tag: tag number of the value field.
You can remove either private or standard data field definitions in
case a particular application uses them for a field of a different
type.
| def remove_raw(self, length_tag, value_tag):
"""Remove the tags for a data type field.
:param length_tag: tag number of the length field.
:param value_tag: tag number of the value field.
You can remove either private or standard data field definitions in
case a particular application uses them for a field of a different
type.
"""
self.raw_len_tags.remove(length_tag)
self.raw_data_tags.remove(value_tag)
| (self, length_tag, value_tag) |
5,790 | simplefix.parser | reset | Reset the internal parser state.
This will discard any appended buffer content, and any fields
parsed so far.
| def reset(self):
"""Reset the internal parser state.
This will discard any appended buffer content, and any fields
parsed so far.
"""
self.buf = b""
self.pairs = []
self.raw_len = 0
| (self) |
5,791 | simplefix.parser | set_allow_empty_values | Accept a zero-length value when parsing.
:param value: If False, raise exception for zero-length values
The FIX specification prohibits zero-length values, instead
suggesting that the field be omitted from the message entirely.
Some implementations do allow a zero-length value, and so this
is accepted by default.
If this setting is disabled, a ValueHasZeroLengthError is
raised from get_message() if such a value is encountered.
| def set_allow_empty_values(self, value=True):
"""Accept a zero-length value when parsing.
:param value: If False, raise exception for zero-length values
The FIX specification prohibits zero-length values, instead
suggesting that the field be omitted from the message entirely.
Some implementations do allow a zero-length value, and so this
is accepted by default.
If this setting is disabled, a ValueHasZeroLengthError is
raised from get_message() if such a value is encountered.
"""
self.allow_empty_values = value
| (self, value=True) |
5,792 | simplefix.parser | set_allow_missing_begin_string | If set, the first field of a message must be BeginString (8).
:param value: If True, check first field is begin.
In some cases, especially FIX-encoded stored data, there might
not be a Begin String (8) at the start of each message.
Note this value cannot be True if strip_fields_before_begin_string
is also True.
| def set_allow_missing_begin_string(self, value=True):
"""If set, the first field of a message must be BeginString (8).
:param value: If True, check first field is begin.
In some cases, especially FIX-encoded stored data, there might
not be a Begin String (8) at the start of each message.
Note this value cannot be True if strip_fields_before_begin_string
is also True.
"""
self.allow_missing_begin_string = value
| (self, value=True) |
5,793 | simplefix.parser | set_message_terminator | Set the end-of-message detection scheme.
:param tag: FIX tag number of terminating field. Default is 10.
:param char: Alternative, terminating character.
THIS METHOD IS DEPRECATED.
Use set_stop_tag(), set_stop_byte(), or constructor keywords
instead.
By default, messages are terminated by the FIX Checksum (10)
field. This can be changed to use a different tag, or a reserved
character using this function.
Note that only one of 'tag' or 'char' should be set, using a
named parameter.
| def set_message_terminator(self, tag=None, char=None):
"""Set the end-of-message detection scheme.
:param tag: FIX tag number of terminating field. Default is 10.
:param char: Alternative, terminating character.
THIS METHOD IS DEPRECATED.
Use set_stop_tag(), set_stop_byte(), or constructor keywords
instead.
By default, messages are terminated by the FIX Checksum (10)
field. This can be changed to use a different tag, or a reserved
character using this function.
Note that only one of 'tag' or 'char' should be set, using a
named parameter.
"""
warnings.warn("simplefix.FixParser.set_message_terminator() is "
"deprecated. Use set_stop_tag(), set_stop_byte(), "
"or constructor keywords instead", DeprecationWarning)
if tag is not None and char is not None:
raise ValueError("Only supply one of 'tag' or 'char'.")
if tag is not None:
self.stop_tag = tag
self.stop_byte = None
else:
self.stop_tag = None
self.stop_byte = ord(char) if char is not None else None
| (self, tag=None, char=None) |
5,794 | simplefix.parser | set_stop_byte | Set a byte value that will terminate a message.
:param value: Byte (character) value, usually CR or LF.
If the parser encounters this byte, anywhere in a message, it is
interpreted as the end of that message. This is often used when
multiple messages are recorded in a file, separated by eg. LF.
Note that this will override the stop_tag value.
Setting the stop_byte to None will disable it.
| def set_stop_byte(self, value: Optional[bytes] = None):
"""Set a byte value that will terminate a message.
:param value: Byte (character) value, usually CR or LF.
If the parser encounters this byte, anywhere in a message, it is
interpreted as the end of that message. This is often used when
multiple messages are recorded in a file, separated by eg. LF.
Note that this will override the stop_tag value.
Setting the stop_byte to None will disable it.
"""
self.stop_byte = ord(value) if value is not None else None
| (self, value: Optional[bytes] = None) |
5,795 | simplefix.parser | set_stop_tag | Set the tag number of the final field in a message.
:param value: Final field tag number.
The default value here is CheckSum (10): the parser recognizes
a 10=xxx field as the end of a message. Note that this value
is overridden if a stop_byte is set.
| def set_stop_tag(self, value: int = DEFAULT_STOP_TAG):
"""Set the tag number of the final field in a message.
:param value: Final field tag number.
The default value here is CheckSum (10): the parser recognizes
a 10=xxx field as the end of a message. Note that this value
is overridden if a stop_byte is set.
"""
self.stop_tag = value
| (self, value: int = 10) |
5,796 | simplefix.parser | set_strip_fields_before_begin_string | Choose whether to discard any fields parsed before 8=FIX.
:param value: If set, discard any fields before the BeginString (8).
Note that this setting cannot be set if a missing BeginString is
also permitted.
| def set_strip_fields_before_begin_string(self, value: bool = True):
"""Choose whether to discard any fields parsed before 8=FIX.
:param value: If set, discard any fields before the BeginString (8).
Note that this setting cannot be set if a missing BeginString is
also permitted.
"""
self.strip_fields_before_begin_string = value
| (self, value: bool = True) |
5,802 | simplefix | pretty_print | Pretty-print a raw FIX buffer.
:param buf: Byte sequence containing raw message.
:param sep: Separator character to use for output, default is '|'.
:returns: Formatted byte array. | def pretty_print(buf, sep='|'):
"""Pretty-print a raw FIX buffer.
:param buf: Byte sequence containing raw message.
:param sep: Separator character to use for output, default is '|'.
:returns: Formatted byte array."""
raw = bytearray(buf)
cooked = bytearray(len(raw))
for i, value in enumerate(raw):
cooked[i] = ord(sep) if value == 1 else value
return bytes(cooked)
| (buf, sep='|') |
5,804 | boto.storage_uri | BucketStorageUri |
StorageUri subclass that handles bucket storage providers.
Callers should instantiate this class by calling boto.storage_uri().
| class BucketStorageUri(StorageUri):
"""
StorageUri subclass that handles bucket storage providers.
Callers should instantiate this class by calling boto.storage_uri().
"""
delim = '/'
capabilities = set([]) # A set of additional capabilities.
def __init__(self, scheme, bucket_name=None, object_name=None,
debug=0, connection_args=None, suppress_consec_slashes=True,
version_id=None, generation=None, is_latest=False):
"""Instantiate a BucketStorageUri from scheme,bucket,object tuple.
@type scheme: string
@param scheme: URI scheme naming the storage provider (gs, s3, etc.)
@type bucket_name: string
@param bucket_name: bucket name
@type object_name: string
@param object_name: object name, excluding generation/version.
@type debug: int
@param debug: debug level to pass in to connection (range 0..2)
@type connection_args: map
@param connection_args: optional map containing args to be
passed to {S3,GS}Connection constructor (e.g., to override
https_connection_factory).
@param suppress_consec_slashes: If provided, controls whether
consecutive slashes will be suppressed in key paths.
@param version_id: Object version id (S3-specific).
@param generation: Object generation number (GCS-specific).
@param is_latest: boolean indicating that a versioned object is the
current version
After instantiation the components are available in the following
fields: scheme, bucket_name, object_name, version_id, generation,
is_latest, versionless_uri, version_specific_uri, uri.
Note: If instantiated without version info, the string representation
for a URI stays versionless; similarly, if instantiated with version
info, the string representation for a URI stays version-specific. If you
call one of the uri.set_contents_from_xyz() methods, a specific object
version will be created, and its version-specific URI string can be
retrieved from version_specific_uri even if the URI was instantiated
without version info.
"""
self.scheme = scheme
self.bucket_name = bucket_name
self.object_name = object_name
self.debug = debug
if connection_args:
self.connection_args = connection_args
self.suppress_consec_slashes = suppress_consec_slashes
self.version_id = version_id
self.generation = generation and int(generation)
self.is_latest = is_latest
self.is_version_specific = bool(self.generation) or bool(version_id)
self._build_uri_strings()
def _build_uri_strings(self):
if self.bucket_name and self.object_name:
self.versionless_uri = '%s://%s/%s' % (self.scheme, self.bucket_name,
self.object_name)
if self.generation:
self.version_specific_uri = '%s#%s' % (self.versionless_uri,
self.generation)
elif self.version_id:
self.version_specific_uri = '%s#%s' % (
self.versionless_uri, self.version_id)
if self.is_version_specific:
self.uri = self.version_specific_uri
else:
self.uri = self.versionless_uri
elif self.bucket_name:
self.uri = ('%s://%s/' % (self.scheme, self.bucket_name))
else:
self.uri = ('%s://' % self.scheme)
def _update_from_key(self, key):
self._update_from_values(
getattr(key, 'version_id', None),
getattr(key, 'generation', None),
getattr(key, 'is_latest', None),
getattr(key, 'md5', None))
def _update_from_values(self, version_id, generation, is_latest, md5):
self.version_id = version_id
self.generation = generation
self.is_latest = is_latest
self._build_uri_strings()
self.md5 = md5
def get_key(self, validate=False, headers=None, version_id=None):
self._check_object_uri('get_key')
bucket = self.get_bucket(validate, headers)
if self.get_provider().name == 'aws':
key = bucket.get_key(self.object_name, headers,
version_id=(version_id or self.version_id))
elif self.get_provider().name == 'google':
key = bucket.get_key(self.object_name, headers,
generation=self.generation)
self.check_response(key, 'key', self.uri)
return key
def delete_key(self, validate=False, headers=None, version_id=None,
mfa_token=None):
self._check_object_uri('delete_key')
bucket = self.get_bucket(validate, headers)
if self.get_provider().name == 'aws':
version_id = version_id or self.version_id
return bucket.delete_key(self.object_name, headers, version_id,
mfa_token)
elif self.get_provider().name == 'google':
return bucket.delete_key(self.object_name, headers,
generation=self.generation)
def clone_replace_name(self, new_name):
"""Instantiate a BucketStorageUri from the current BucketStorageUri,
but replacing the object_name.
@type new_name: string
@param new_name: new object name
"""
self._check_bucket_uri('clone_replace_name')
return BucketStorageUri(
self.scheme, bucket_name=self.bucket_name, object_name=new_name,
debug=self.debug,
suppress_consec_slashes=self.suppress_consec_slashes)
def clone_replace_key(self, key):
"""Instantiate a BucketStorageUri from the current BucketStorageUri, by
replacing the object name with the object name and other metadata found
in the given Key object (including generation).
@type key: Key
@param key: key for the new StorageUri to represent
"""
self._check_bucket_uri('clone_replace_key')
version_id = None
generation = None
is_latest = False
if hasattr(key, 'version_id'):
version_id = key.version_id
if hasattr(key, 'generation'):
generation = key.generation
if hasattr(key, 'is_latest'):
is_latest = key.is_latest
return BucketStorageUri(
key.provider.get_provider_name(),
bucket_name=key.bucket.name,
object_name=key.name,
debug=self.debug,
suppress_consec_slashes=self.suppress_consec_slashes,
version_id=version_id,
generation=generation,
is_latest=is_latest)
def get_acl(self, validate=False, headers=None, version_id=None):
"""returns a bucket's acl"""
self._check_bucket_uri('get_acl')
bucket = self.get_bucket(validate, headers)
# This works for both bucket- and object- level ACLs (former passes
# key_name=None):
key_name = self.object_name or ''
if self.get_provider().name == 'aws':
version_id = version_id or self.version_id
acl = bucket.get_acl(key_name, headers, version_id)
else:
acl = bucket.get_acl(key_name, headers, generation=self.generation)
self.check_response(acl, 'acl', self.uri)
return acl
def get_def_acl(self, validate=False, headers=None):
"""returns a bucket's default object acl"""
self._check_bucket_uri('get_def_acl')
bucket = self.get_bucket(validate, headers)
acl = bucket.get_def_acl(headers)
self.check_response(acl, 'acl', self.uri)
return acl
def get_cors(self, validate=False, headers=None):
"""returns a bucket's CORS XML"""
self._check_bucket_uri('get_cors')
bucket = self.get_bucket(validate, headers)
cors = bucket.get_cors(headers)
self.check_response(cors, 'cors', self.uri)
return cors
def set_cors(self, cors, validate=False, headers=None):
"""sets or updates a bucket's CORS XML"""
self._check_bucket_uri('set_cors ')
bucket = self.get_bucket(validate, headers)
if self.scheme == 's3':
bucket.set_cors(cors, headers)
else:
bucket.set_cors(cors.to_xml(), headers)
def get_location(self, validate=False, headers=None):
self._check_bucket_uri('get_location')
bucket = self.get_bucket(validate, headers)
return bucket.get_location(headers)
def get_storage_class(self, validate=False, headers=None):
self._check_bucket_uri('get_storage_class')
# StorageClass is defined as a bucket and object param for GCS, but
# only as a key param for S3.
if self.scheme != 'gs':
raise ValueError('get_storage_class() not supported for %s '
'URIs.' % self.scheme)
bucket = self.get_bucket(validate, headers)
return bucket.get_storage_class(headers)
def set_storage_class(self, storage_class, validate=False, headers=None):
"""Updates a bucket's storage class."""
self._check_bucket_uri('set_storage_class')
# StorageClass is defined as a bucket and object param for GCS, but
# only as a key param for S3.
if self.scheme != 'gs':
raise ValueError('set_storage_class() not supported for %s '
'URIs.' % self.scheme)
bucket = self.get_bucket(validate, headers)
bucket.set_storage_class(storage_class, headers)
def get_subresource(self, subresource, validate=False, headers=None,
version_id=None):
self._check_bucket_uri('get_subresource')
bucket = self.get_bucket(validate, headers)
return bucket.get_subresource(subresource, self.object_name, headers,
version_id)
def add_group_email_grant(self, permission, email_address, recursive=False,
validate=False, headers=None):
self._check_bucket_uri('add_group_email_grant')
if self.scheme != 'gs':
raise ValueError('add_group_email_grant() not supported for %s '
'URIs.' % self.scheme)
if self.object_name:
if recursive:
raise ValueError('add_group_email_grant() on key-ful URI cannot '
'specify recursive=True')
key = self.get_key(validate, headers)
self.check_response(key, 'key', self.uri)
key.add_group_email_grant(permission, email_address, headers)
elif self.bucket_name:
bucket = self.get_bucket(validate, headers)
bucket.add_group_email_grant(permission, email_address, recursive,
headers)
else:
raise InvalidUriError('add_group_email_grant() on bucket-less URI '
'%s' % self.uri)
def add_email_grant(self, permission, email_address, recursive=False,
validate=False, headers=None):
self._check_bucket_uri('add_email_grant')
if not self.object_name:
bucket = self.get_bucket(validate, headers)
bucket.add_email_grant(permission, email_address, recursive,
headers)
else:
key = self.get_key(validate, headers)
self.check_response(key, 'key', self.uri)
key.add_email_grant(permission, email_address)
def add_user_grant(self, permission, user_id, recursive=False,
validate=False, headers=None):
self._check_bucket_uri('add_user_grant')
if not self.object_name:
bucket = self.get_bucket(validate, headers)
bucket.add_user_grant(permission, user_id, recursive, headers)
else:
key = self.get_key(validate, headers)
self.check_response(key, 'key', self.uri)
key.add_user_grant(permission, user_id)
def list_grants(self, headers=None):
self._check_bucket_uri('list_grants ')
bucket = self.get_bucket(headers)
return bucket.list_grants(headers)
def is_file_uri(self):
"""Returns True if this URI names a file or directory."""
return False
def is_cloud_uri(self):
"""Returns True if this URI names a bucket or object."""
return True
def names_container(self):
"""
Returns True if this URI names a directory or bucket. Will return
False for bucket subdirs; providing bucket subdir semantics needs to
be done by the caller (like gsutil does).
"""
return bool(not self.object_name)
def names_singleton(self):
"""Returns True if this URI names a file or object."""
return bool(self.object_name)
def names_directory(self):
"""Returns True if this URI names a directory."""
return False
def names_provider(self):
"""Returns True if this URI names a provider."""
return bool(not self.bucket_name)
def names_bucket(self):
"""Returns True if this URI names a bucket."""
return bool(self.bucket_name) and bool(not self.object_name)
def names_file(self):
"""Returns True if this URI names a file."""
return False
def names_object(self):
"""Returns True if this URI names an object."""
return self.names_singleton()
def is_stream(self):
"""Returns True if this URI represents input/output stream."""
return False
def create_bucket(self, headers=None, location='', policy=None,
storage_class=None):
self._check_bucket_uri('create_bucket ')
conn = self.connect()
# Pass storage_class param only if this is a GCS bucket. (In S3 the
# storage class is specified on the key object.)
if self.scheme == 'gs':
return conn.create_bucket(self.bucket_name, headers, location, policy,
storage_class)
else:
return conn.create_bucket(self.bucket_name, headers, location, policy)
def delete_bucket(self, headers=None):
self._check_bucket_uri('delete_bucket')
conn = self.connect()
return conn.delete_bucket(self.bucket_name, headers)
def get_all_buckets(self, headers=None):
conn = self.connect()
return conn.get_all_buckets(headers)
def get_provider(self):
conn = self.connect()
provider = conn.provider
self.check_response(provider, 'provider', self.uri)
return provider
def set_acl(self, acl_or_str, key_name='', validate=False, headers=None,
version_id=None, if_generation=None, if_metageneration=None):
"""Sets or updates a bucket's ACL."""
self._check_bucket_uri('set_acl')
key_name = key_name or self.object_name or ''
bucket = self.get_bucket(validate, headers)
if self.generation:
bucket.set_acl(
acl_or_str, key_name, headers, generation=self.generation,
if_generation=if_generation, if_metageneration=if_metageneration)
else:
version_id = version_id or self.version_id
bucket.set_acl(acl_or_str, key_name, headers, version_id)
def set_xml_acl(self, xmlstring, key_name='', validate=False, headers=None,
version_id=None, if_generation=None, if_metageneration=None):
"""Sets or updates a bucket's ACL with an XML string."""
self._check_bucket_uri('set_xml_acl')
key_name = key_name or self.object_name or ''
bucket = self.get_bucket(validate, headers)
if self.generation:
bucket.set_xml_acl(
xmlstring, key_name, headers, generation=self.generation,
if_generation=if_generation, if_metageneration=if_metageneration)
else:
version_id = version_id or self.version_id
bucket.set_xml_acl(xmlstring, key_name, headers,
version_id=version_id)
def set_def_xml_acl(self, xmlstring, validate=False, headers=None):
"""Sets or updates a bucket's default object ACL with an XML string."""
self._check_bucket_uri('set_def_xml_acl')
self.get_bucket(validate, headers).set_def_xml_acl(xmlstring, headers)
def set_def_acl(self, acl_or_str, validate=False, headers=None,
version_id=None):
"""Sets or updates a bucket's default object ACL."""
self._check_bucket_uri('set_def_acl')
self.get_bucket(validate, headers).set_def_acl(acl_or_str, headers)
def set_canned_acl(self, acl_str, validate=False, headers=None,
version_id=None):
"""Sets or updates a bucket's acl to a predefined (canned) value."""
self._check_object_uri('set_canned_acl')
self._warn_about_args('set_canned_acl', version_id=version_id)
key = self.get_key(validate, headers)
self.check_response(key, 'key', self.uri)
key.set_canned_acl(acl_str, headers)
def set_def_canned_acl(self, acl_str, validate=False, headers=None,
version_id=None):
"""Sets or updates a bucket's default object acl to a predefined
(canned) value."""
self._check_bucket_uri('set_def_canned_acl ')
key = self.get_key(validate, headers)
self.check_response(key, 'key', self.uri)
key.set_def_canned_acl(acl_str, headers, version_id)
def set_subresource(self, subresource, value, validate=False, headers=None,
version_id=None):
self._check_bucket_uri('set_subresource')
bucket = self.get_bucket(validate, headers)
bucket.set_subresource(subresource, value, self.object_name, headers,
version_id)
def set_contents_from_string(self, s, headers=None, replace=True,
cb=None, num_cb=10, policy=None, md5=None,
reduced_redundancy=False):
self._check_object_uri('set_contents_from_string')
key = self.new_key(headers=headers)
if self.scheme == 'gs':
if reduced_redundancy:
sys.stderr.write('Warning: GCS does not support '
'reduced_redundancy; argument ignored by '
'set_contents_from_string')
result = key.set_contents_from_string(
s, headers, replace, cb, num_cb, policy, md5)
else:
result = key.set_contents_from_string(
s, headers, replace, cb, num_cb, policy, md5,
reduced_redundancy)
self._update_from_key(key)
return result
def set_contents_from_file(self, fp, headers=None, replace=True, cb=None,
num_cb=10, policy=None, md5=None, size=None,
rewind=False, res_upload_handler=None):
self._check_object_uri('set_contents_from_file')
key = self.new_key(headers=headers)
if self.scheme == 'gs':
result = key.set_contents_from_file(
fp, headers, replace, cb, num_cb, policy, md5, size=size,
rewind=rewind, res_upload_handler=res_upload_handler)
if res_upload_handler:
self._update_from_values(None, res_upload_handler.generation,
None, md5)
else:
self._warn_about_args('set_contents_from_file',
res_upload_handler=res_upload_handler)
result = key.set_contents_from_file(
fp, headers, replace, cb, num_cb, policy, md5, size=size,
rewind=rewind)
self._update_from_key(key)
return result
def set_contents_from_stream(self, fp, headers=None, replace=True, cb=None,
policy=None, reduced_redundancy=False):
self._check_object_uri('set_contents_from_stream')
dst_key = self.new_key(False, headers)
result = dst_key.set_contents_from_stream(
fp, headers, replace, cb, policy=policy,
reduced_redundancy=reduced_redundancy)
self._update_from_key(dst_key)
return result
def copy_key(self, src_bucket_name, src_key_name, metadata=None,
src_version_id=None, storage_class='STANDARD',
preserve_acl=False, encrypt_key=False, headers=None,
query_args=None, src_generation=None):
"""Returns newly created key."""
self._check_object_uri('copy_key')
dst_bucket = self.get_bucket(validate=False, headers=headers)
if src_generation:
return dst_bucket.copy_key(
new_key_name=self.object_name,
src_bucket_name=src_bucket_name,
src_key_name=src_key_name, metadata=metadata,
storage_class=storage_class, preserve_acl=preserve_acl,
encrypt_key=encrypt_key, headers=headers, query_args=query_args,
src_generation=src_generation)
else:
return dst_bucket.copy_key(
new_key_name=self.object_name,
src_bucket_name=src_bucket_name, src_key_name=src_key_name,
metadata=metadata, src_version_id=src_version_id,
storage_class=storage_class, preserve_acl=preserve_acl,
encrypt_key=encrypt_key, headers=headers, query_args=query_args)
def enable_logging(self, target_bucket, target_prefix=None, validate=False,
headers=None, version_id=None):
self._check_bucket_uri('enable_logging')
bucket = self.get_bucket(validate, headers)
bucket.enable_logging(target_bucket, target_prefix, headers=headers)
def disable_logging(self, validate=False, headers=None, version_id=None):
self._check_bucket_uri('disable_logging')
bucket = self.get_bucket(validate, headers)
bucket.disable_logging(headers=headers)
def get_logging_config(self, validate=False, headers=None, version_id=None):
self._check_bucket_uri('get_logging_config')
bucket = self.get_bucket(validate, headers)
return bucket.get_logging_config(headers=headers)
def set_website_config(self, main_page_suffix=None, error_key=None,
validate=False, headers=None):
self._check_bucket_uri('set_website_config')
bucket = self.get_bucket(validate, headers)
if not (main_page_suffix or error_key):
bucket.delete_website_configuration(headers)
else:
bucket.configure_website(main_page_suffix, error_key, headers)
def get_website_config(self, validate=False, headers=None):
self._check_bucket_uri('get_website_config')
bucket = self.get_bucket(validate, headers)
return bucket.get_website_configuration(headers)
def get_versioning_config(self, headers=None):
self._check_bucket_uri('get_versioning_config')
bucket = self.get_bucket(False, headers)
return bucket.get_versioning_status(headers)
def configure_versioning(self, enabled, headers=None):
self._check_bucket_uri('configure_versioning')
bucket = self.get_bucket(False, headers)
return bucket.configure_versioning(enabled, headers)
def set_metadata(self, metadata_plus, metadata_minus, preserve_acl,
headers=None):
return self.get_key(False).set_remote_metadata(metadata_plus,
metadata_minus,
preserve_acl,
headers=headers)
def compose(self, components, content_type=None, headers=None):
self._check_object_uri('compose')
component_keys = []
for suri in components:
component_keys.append(suri.new_key())
component_keys[-1].generation = suri.generation
self.generation = self.new_key().compose(
component_keys, content_type=content_type, headers=headers)
self._build_uri_strings()
return self
def get_lifecycle_config(self, validate=False, headers=None):
"""Returns a bucket's lifecycle configuration."""
self._check_bucket_uri('get_lifecycle_config')
bucket = self.get_bucket(validate, headers)
lifecycle_config = bucket.get_lifecycle_config(headers)
self.check_response(lifecycle_config, 'lifecycle', self.uri)
return lifecycle_config
def configure_lifecycle(self, lifecycle_config, validate=False,
headers=None):
"""Sets or updates a bucket's lifecycle configuration."""
self._check_bucket_uri('configure_lifecycle')
bucket = self.get_bucket(validate, headers)
bucket.configure_lifecycle(lifecycle_config, headers)
def get_billing_config(self, headers=None):
self._check_bucket_uri('get_billing_config')
# billing is defined as a bucket param for GCS, but not for S3.
if self.scheme != 'gs':
raise ValueError('get_billing_config() not supported for %s '
'URIs.' % self.scheme)
bucket = self.get_bucket(False, headers)
return bucket.get_billing_config(headers)
def configure_billing(self, requester_pays=False, validate=False,
headers=None):
"""Sets or updates a bucket's billing configuration."""
self._check_bucket_uri('configure_billing')
# billing is defined as a bucket param for GCS, but not for S3.
if self.scheme != 'gs':
raise ValueError('configure_billing() not supported for %s '
'URIs.' % self.scheme)
bucket = self.get_bucket(validate, headers)
bucket.configure_billing(requester_pays=requester_pays, headers=headers)
def get_encryption_config(self, validate=False, headers=None):
"""Returns a GCS bucket's encryption configuration."""
self._check_bucket_uri('get_encryption_config')
# EncryptionConfiguration is defined as a bucket param for GCS, but not
# for S3.
if self.scheme != 'gs':
raise ValueError('get_encryption_config() not supported for %s '
'URIs.' % self.scheme)
bucket = self.get_bucket(validate, headers)
return bucket.get_encryption_config(headers=headers)
def set_encryption_config(self, default_kms_key_name=None, validate=False,
headers=None):
"""Sets a GCS bucket's encryption configuration."""
self._check_bucket_uri('set_encryption_config')
bucket = self.get_bucket(validate, headers)
bucket.set_encryption_config(default_kms_key_name=default_kms_key_name,
headers=headers)
def exists(self, headers=None):
"""Returns True if the object exists or False if it doesn't"""
if not self.object_name:
raise InvalidUriError('exists on object-less URI (%s)' % self.uri)
bucket = self.get_bucket(headers)
key = bucket.get_key(self.object_name, headers=headers)
return bool(key)
| (scheme, bucket_name=None, object_name=None, debug=0, connection_args=None, suppress_consec_slashes=True, version_id=None, generation=None, is_latest=False) |
5,805 | boto.storage_uri | __init__ | Instantiate a BucketStorageUri from scheme,bucket,object tuple.
@type scheme: string
@param scheme: URI scheme naming the storage provider (gs, s3, etc.)
@type bucket_name: string
@param bucket_name: bucket name
@type object_name: string
@param object_name: object name, excluding generation/version.
@type debug: int
@param debug: debug level to pass in to connection (range 0..2)
@type connection_args: map
@param connection_args: optional map containing args to be
passed to {S3,GS}Connection constructor (e.g., to override
https_connection_factory).
@param suppress_consec_slashes: If provided, controls whether
consecutive slashes will be suppressed in key paths.
@param version_id: Object version id (S3-specific).
@param generation: Object generation number (GCS-specific).
@param is_latest: boolean indicating that a versioned object is the
current version
After instantiation the components are available in the following
fields: scheme, bucket_name, object_name, version_id, generation,
is_latest, versionless_uri, version_specific_uri, uri.
Note: If instantiated without version info, the string representation
for a URI stays versionless; similarly, if instantiated with version
info, the string representation for a URI stays version-specific. If you
call one of the uri.set_contents_from_xyz() methods, a specific object
version will be created, and its version-specific URI string can be
retrieved from version_specific_uri even if the URI was instantiated
without version info.
| def __init__(self, scheme, bucket_name=None, object_name=None,
debug=0, connection_args=None, suppress_consec_slashes=True,
version_id=None, generation=None, is_latest=False):
"""Instantiate a BucketStorageUri from scheme,bucket,object tuple.
@type scheme: string
@param scheme: URI scheme naming the storage provider (gs, s3, etc.)
@type bucket_name: string
@param bucket_name: bucket name
@type object_name: string
@param object_name: object name, excluding generation/version.
@type debug: int
@param debug: debug level to pass in to connection (range 0..2)
@type connection_args: map
@param connection_args: optional map containing args to be
passed to {S3,GS}Connection constructor (e.g., to override
https_connection_factory).
@param suppress_consec_slashes: If provided, controls whether
consecutive slashes will be suppressed in key paths.
@param version_id: Object version id (S3-specific).
@param generation: Object generation number (GCS-specific).
@param is_latest: boolean indicating that a versioned object is the
current version
After instantiation the components are available in the following
fields: scheme, bucket_name, object_name, version_id, generation,
is_latest, versionless_uri, version_specific_uri, uri.
Note: If instantiated without version info, the string representation
for a URI stays versionless; similarly, if instantiated with version
info, the string representation for a URI stays version-specific. If you
call one of the uri.set_contents_from_xyz() methods, a specific object
version will be created, and its version-specific URI string can be
retrieved from version_specific_uri even if the URI was instantiated
without version info.
"""
self.scheme = scheme
self.bucket_name = bucket_name
self.object_name = object_name
self.debug = debug
if connection_args:
self.connection_args = connection_args
self.suppress_consec_slashes = suppress_consec_slashes
self.version_id = version_id
self.generation = generation and int(generation)
self.is_latest = is_latest
self.is_version_specific = bool(self.generation) or bool(version_id)
self._build_uri_strings()
| (self, scheme, bucket_name=None, object_name=None, debug=0, connection_args=None, suppress_consec_slashes=True, version_id=None, generation=None, is_latest=False) |
5,806 | boto.storage_uri | __repr__ | Returns string representation of URI. | def __repr__(self):
"""Returns string representation of URI."""
return self.uri
| (self) |
5,807 | boto.storage_uri | _build_uri_strings | null | def _build_uri_strings(self):
if self.bucket_name and self.object_name:
self.versionless_uri = '%s://%s/%s' % (self.scheme, self.bucket_name,
self.object_name)
if self.generation:
self.version_specific_uri = '%s#%s' % (self.versionless_uri,
self.generation)
elif self.version_id:
self.version_specific_uri = '%s#%s' % (
self.versionless_uri, self.version_id)
if self.is_version_specific:
self.uri = self.version_specific_uri
else:
self.uri = self.versionless_uri
elif self.bucket_name:
self.uri = ('%s://%s/' % (self.scheme, self.bucket_name))
else:
self.uri = ('%s://' % self.scheme)
| (self) |
5,808 | boto.storage_uri | _check_bucket_uri | null | def _check_bucket_uri(self, function_name):
if issubclass(type(self), BucketStorageUri) and not self.bucket_name:
raise InvalidUriError(
'%s on bucket-less URI (%s)' % (function_name, self.uri))
| (self, function_name) |
5,809 | boto.storage_uri | _check_object_uri | null | def _check_object_uri(self, function_name):
if issubclass(type(self), BucketStorageUri) and not self.object_name:
raise InvalidUriError('%s on object-less URI (%s)' %
(function_name, self.uri))
| (self, function_name) |
5,810 | boto.storage_uri | _update_from_key | null | def _update_from_key(self, key):
self._update_from_values(
getattr(key, 'version_id', None),
getattr(key, 'generation', None),
getattr(key, 'is_latest', None),
getattr(key, 'md5', None))
| (self, key) |
5,811 | boto.storage_uri | _update_from_values | null | def _update_from_values(self, version_id, generation, is_latest, md5):
self.version_id = version_id
self.generation = generation
self.is_latest = is_latest
self._build_uri_strings()
self.md5 = md5
| (self, version_id, generation, is_latest, md5) |
5,812 | boto.storage_uri | _warn_about_args | null | def _warn_about_args(self, function_name, **args):
for arg in args:
if args[arg]:
sys.stderr.write(
'Warning: %s ignores argument: %s=%s\n' %
(function_name, arg, str(args[arg])))
| (self, function_name, **args) |
5,813 | boto.storage_uri | acl_class | null | def acl_class(self):
conn = self.connect()
acl_class = conn.provider.acl_class
self.check_response(acl_class, 'acl_class', self.uri)
return acl_class
| (self) |
5,814 | boto.storage_uri | add_email_grant | null | def add_email_grant(self, permission, email_address, recursive=False,
validate=False, headers=None):
self._check_bucket_uri('add_email_grant')
if not self.object_name:
bucket = self.get_bucket(validate, headers)
bucket.add_email_grant(permission, email_address, recursive,
headers)
else:
key = self.get_key(validate, headers)
self.check_response(key, 'key', self.uri)
key.add_email_grant(permission, email_address)
| (self, permission, email_address, recursive=False, validate=False, headers=None) |
5,815 | boto.storage_uri | add_group_email_grant | null | def add_group_email_grant(self, permission, email_address, recursive=False,
validate=False, headers=None):
self._check_bucket_uri('add_group_email_grant')
if self.scheme != 'gs':
raise ValueError('add_group_email_grant() not supported for %s '
'URIs.' % self.scheme)
if self.object_name:
if recursive:
raise ValueError('add_group_email_grant() on key-ful URI cannot '
'specify recursive=True')
key = self.get_key(validate, headers)
self.check_response(key, 'key', self.uri)
key.add_group_email_grant(permission, email_address, headers)
elif self.bucket_name:
bucket = self.get_bucket(validate, headers)
bucket.add_group_email_grant(permission, email_address, recursive,
headers)
else:
raise InvalidUriError('add_group_email_grant() on bucket-less URI '
'%s' % self.uri)
| (self, permission, email_address, recursive=False, validate=False, headers=None) |
5,816 | boto.storage_uri | add_user_grant | null | def add_user_grant(self, permission, user_id, recursive=False,
validate=False, headers=None):
self._check_bucket_uri('add_user_grant')
if not self.object_name:
bucket = self.get_bucket(validate, headers)
bucket.add_user_grant(permission, user_id, recursive, headers)
else:
key = self.get_key(validate, headers)
self.check_response(key, 'key', self.uri)
key.add_user_grant(permission, user_id)
| (self, permission, user_id, recursive=False, validate=False, headers=None) |
5,817 | boto.storage_uri | canned_acls | null | def canned_acls(self):
conn = self.connect()
canned_acls = conn.provider.canned_acls
self.check_response(canned_acls, 'canned_acls', self.uri)
return canned_acls
| (self) |
5,818 | boto.storage_uri | check_response | null | def check_response(self, resp, level, uri):
if resp is None:
raise InvalidUriError('\n'.join(textwrap.wrap(
'Attempt to get %s for "%s" failed. This can happen if '
'the URI refers to a non-existent object or if you meant to '
'operate on a directory (e.g., leaving off -R option on gsutil '
'cp, mv, or ls of a bucket)' % (level, uri), 80)))
| (self, resp, level, uri) |
5,819 | boto.storage_uri | clone_replace_key | Instantiate a BucketStorageUri from the current BucketStorageUri, by
replacing the object name with the object name and other metadata found
in the given Key object (including generation).
@type key: Key
@param key: key for the new StorageUri to represent
| def clone_replace_key(self, key):
"""Instantiate a BucketStorageUri from the current BucketStorageUri, by
replacing the object name with the object name and other metadata found
in the given Key object (including generation).
@type key: Key
@param key: key for the new StorageUri to represent
"""
self._check_bucket_uri('clone_replace_key')
version_id = None
generation = None
is_latest = False
if hasattr(key, 'version_id'):
version_id = key.version_id
if hasattr(key, 'generation'):
generation = key.generation
if hasattr(key, 'is_latest'):
is_latest = key.is_latest
return BucketStorageUri(
key.provider.get_provider_name(),
bucket_name=key.bucket.name,
object_name=key.name,
debug=self.debug,
suppress_consec_slashes=self.suppress_consec_slashes,
version_id=version_id,
generation=generation,
is_latest=is_latest)
| (self, key) |
5,820 | boto.storage_uri | clone_replace_name | Instantiate a BucketStorageUri from the current BucketStorageUri,
but replacing the object_name.
@type new_name: string
@param new_name: new object name
| def clone_replace_name(self, new_name):
"""Instantiate a BucketStorageUri from the current BucketStorageUri,
but replacing the object_name.
@type new_name: string
@param new_name: new object name
"""
self._check_bucket_uri('clone_replace_name')
return BucketStorageUri(
self.scheme, bucket_name=self.bucket_name, object_name=new_name,
debug=self.debug,
suppress_consec_slashes=self.suppress_consec_slashes)
| (self, new_name) |
5,821 | boto.storage_uri | compose | null | def compose(self, components, content_type=None, headers=None):
self._check_object_uri('compose')
component_keys = []
for suri in components:
component_keys.append(suri.new_key())
component_keys[-1].generation = suri.generation
self.generation = self.new_key().compose(
component_keys, content_type=content_type, headers=headers)
self._build_uri_strings()
return self
| (self, components, content_type=None, headers=None) |
5,822 | boto.storage_uri | configure_billing | Sets or updates a bucket's billing configuration. | def configure_billing(self, requester_pays=False, validate=False,
headers=None):
"""Sets or updates a bucket's billing configuration."""
self._check_bucket_uri('configure_billing')
# billing is defined as a bucket param for GCS, but not for S3.
if self.scheme != 'gs':
raise ValueError('configure_billing() not supported for %s '
'URIs.' % self.scheme)
bucket = self.get_bucket(validate, headers)
bucket.configure_billing(requester_pays=requester_pays, headers=headers)
| (self, requester_pays=False, validate=False, headers=None) |
5,823 | boto.storage_uri | configure_lifecycle | Sets or updates a bucket's lifecycle configuration. | def configure_lifecycle(self, lifecycle_config, validate=False,
headers=None):
"""Sets or updates a bucket's lifecycle configuration."""
self._check_bucket_uri('configure_lifecycle')
bucket = self.get_bucket(validate, headers)
bucket.configure_lifecycle(lifecycle_config, headers)
| (self, lifecycle_config, validate=False, headers=None) |
5,824 | boto.storage_uri | configure_versioning | null | def configure_versioning(self, enabled, headers=None):
self._check_bucket_uri('configure_versioning')
bucket = self.get_bucket(False, headers)
return bucket.configure_versioning(enabled, headers)
| (self, enabled, headers=None) |
5,825 | boto.storage_uri | connect |
Opens a connection to appropriate provider, depending on provider
portion of URI. Requires Credentials defined in boto config file (see
boto/pyami/config.py).
@type storage_uri: StorageUri
@param storage_uri: StorageUri specifying a bucket or a bucket+object
@rtype: L{AWSAuthConnection<boto.gs.connection.AWSAuthConnection>}
@return: A connection to storage service provider of the given URI.
| def connect(self, access_key_id=None, secret_access_key=None, **kwargs):
"""
Opens a connection to appropriate provider, depending on provider
portion of URI. Requires Credentials defined in boto config file (see
boto/pyami/config.py).
@type storage_uri: StorageUri
@param storage_uri: StorageUri specifying a bucket or a bucket+object
@rtype: L{AWSAuthConnection<boto.gs.connection.AWSAuthConnection>}
@return: A connection to storage service provider of the given URI.
"""
connection_args = dict(self.connection_args or ())
if (hasattr(self, 'suppress_consec_slashes') and
'suppress_consec_slashes' not in connection_args):
connection_args['suppress_consec_slashes'] = (
self.suppress_consec_slashes)
connection_args.update(kwargs)
if not self.connection:
if self.scheme in self.provider_pool:
self.connection = self.provider_pool[self.scheme]
elif self.scheme == 's3':
from boto.s3.connection import S3Connection
self.connection = S3Connection(access_key_id,
secret_access_key,
**connection_args)
self.provider_pool[self.scheme] = self.connection
elif self.scheme == 'gs':
from boto.gs.connection import GSConnection
# Use OrdinaryCallingFormat instead of boto-default
# SubdomainCallingFormat because the latter changes the hostname
# that's checked during cert validation for HTTPS connections,
# which will fail cert validation (when cert validation is
# enabled).
#
# The same is not true for S3's HTTPS certificates. In fact,
# we don't want to do this for S3 because S3 requires the
# subdomain to match the location of the bucket. If the proper
# subdomain is not used, the server will return a 301 redirect
# with no Location header.
#
# Note: the following import can't be moved up to the
# start of this file else it causes a config import failure when
# run from the resumable upload/download tests.
from boto.s3.connection import OrdinaryCallingFormat
connection_args['calling_format'] = OrdinaryCallingFormat()
self.connection = GSConnection(access_key_id,
secret_access_key,
**connection_args)
self.provider_pool[self.scheme] = self.connection
elif self.scheme == 'file':
from boto.file.connection import FileConnection
self.connection = FileConnection(self)
else:
raise InvalidUriError('Unrecognized scheme "%s"' %
self.scheme)
self.connection.debug = self.debug
return self.connection
| (self, access_key_id=None, secret_access_key=None, **kwargs) |
5,826 | boto.storage_uri | copy_key | Returns newly created key. | def copy_key(self, src_bucket_name, src_key_name, metadata=None,
src_version_id=None, storage_class='STANDARD',
preserve_acl=False, encrypt_key=False, headers=None,
query_args=None, src_generation=None):
"""Returns newly created key."""
self._check_object_uri('copy_key')
dst_bucket = self.get_bucket(validate=False, headers=headers)
if src_generation:
return dst_bucket.copy_key(
new_key_name=self.object_name,
src_bucket_name=src_bucket_name,
src_key_name=src_key_name, metadata=metadata,
storage_class=storage_class, preserve_acl=preserve_acl,
encrypt_key=encrypt_key, headers=headers, query_args=query_args,
src_generation=src_generation)
else:
return dst_bucket.copy_key(
new_key_name=self.object_name,
src_bucket_name=src_bucket_name, src_key_name=src_key_name,
metadata=metadata, src_version_id=src_version_id,
storage_class=storage_class, preserve_acl=preserve_acl,
encrypt_key=encrypt_key, headers=headers, query_args=query_args)
| (self, src_bucket_name, src_key_name, metadata=None, src_version_id=None, storage_class='STANDARD', preserve_acl=False, encrypt_key=False, headers=None, query_args=None, src_generation=None) |
5,827 | boto.storage_uri | create_bucket | null | def create_bucket(self, headers=None, location='', policy=None,
storage_class=None):
self._check_bucket_uri('create_bucket ')
conn = self.connect()
# Pass storage_class param only if this is a GCS bucket. (In S3 the
# storage class is specified on the key object.)
if self.scheme == 'gs':
return conn.create_bucket(self.bucket_name, headers, location, policy,
storage_class)
else:
return conn.create_bucket(self.bucket_name, headers, location, policy)
| (self, headers=None, location='', policy=None, storage_class=None) |
5,828 | boto.storage_uri | delete_bucket | null | def delete_bucket(self, headers=None):
self._check_bucket_uri('delete_bucket')
conn = self.connect()
return conn.delete_bucket(self.bucket_name, headers)
| (self, headers=None) |
5,829 | boto.storage_uri | delete_key | null | def delete_key(self, validate=False, headers=None, version_id=None,
mfa_token=None):
self._check_object_uri('delete_key')
bucket = self.get_bucket(validate, headers)
if self.get_provider().name == 'aws':
version_id = version_id or self.version_id
return bucket.delete_key(self.object_name, headers, version_id,
mfa_token)
elif self.get_provider().name == 'google':
return bucket.delete_key(self.object_name, headers,
generation=self.generation)
| (self, validate=False, headers=None, version_id=None, mfa_token=None) |
5,830 | boto.storage_uri | disable_logging | null | def disable_logging(self, validate=False, headers=None, version_id=None):
self._check_bucket_uri('disable_logging')
bucket = self.get_bucket(validate, headers)
bucket.disable_logging(headers=headers)
| (self, validate=False, headers=None, version_id=None) |
5,831 | boto.storage_uri | enable_logging | null | def enable_logging(self, target_bucket, target_prefix=None, validate=False,
headers=None, version_id=None):
self._check_bucket_uri('enable_logging')
bucket = self.get_bucket(validate, headers)
bucket.enable_logging(target_bucket, target_prefix, headers=headers)
| (self, target_bucket, target_prefix=None, validate=False, headers=None, version_id=None) |
5,832 | boto.storage_uri | equals | Returns true if two URIs are equal. | def equals(self, uri):
"""Returns true if two URIs are equal."""
return self.uri == uri.uri
| (self, uri) |
Subsets and Splits