_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 31 13.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q14500 | AWSAuth.get_token | train | def get_token(self):
"""Returns a client token from Cerberus"""
signed_headers = self._get_v4_signed_headers()
for header in self.HEADERS:
signed_headers[header] = self.HEADERS[header]
resp = post_with_retry(self.cerberus_url + '/v2/auth/sts-identity', headers=signed_headers... | python | {
"resource": ""
} |
q14501 | tiff_header | train | def tiff_header(read_buffer):
"""
Interpret the uuid raw data as a tiff header.
"""
# First 8 should be (73, 73, 42, 8) or (77, 77, 42, 8)
data = struct.unpack('BB', read_buffer[0:2])
if data[0] == 73 and data[1] == 73:
# little endian
endian = '<'
elif data[0] == 77 and data... | python | {
"resource": ""
} |
q14502 | Ifd.parse_tag | train | def parse_tag(self, dtype, count, offset_buf):
"""Interpret an Exif image tag data payload.
"""
try:
fmt = self.datatype2fmt[dtype][0] * count
payload_size = self.datatype2fmt[dtype][1] * count
except KeyError:
msg = 'Invalid TIFF tag datatype ({0}).'.... | python | {
"resource": ""
} |
q14503 | Ifd.post_process | train | def post_process(self, tagnum2name):
"""Map the tag name instead of tag number to the tag value.
"""
for tag, value in self.raw_ifd.items():
try:
tag_name = tagnum2name[tag]
except KeyError:
# Ok, we don't recognize this | python | {
"resource": ""
} |
q14504 | SavedQueriesInterface.all | train | def all(self):
"""
Gets all saved queries for a project from the Keen IO API.
Master key must be set.
"""
| python | {
"resource": ""
} |
q14505 | SavedQueriesInterface.get | train | def get(self, query_name):
"""
Gets a single saved query for a project from the Keen IO API given a
query name.
Master key must be set.
"""
| python | {
"resource": ""
} |
q14506 | SavedQueriesInterface.results | train | def results(self, query_name):
"""
Gets a single saved query with a 'result' object for a project from the
Keen IO API given a query name.
Read or Master key must be set.
"""
url = | python | {
"resource": ""
} |
q14507 | SavedQueriesInterface.create | train | def create(self, query_name, saved_query):
"""
Creates the saved query via a PUT request to Keen IO Saved Query endpoint.
Master key must be set.
"""
url = "{0}/{1}".format(self.saved_query_url, query_name)
payload = saved_query
# To support clients that may have... | python | {
"resource": ""
} |
q14508 | SavedQueriesInterface.delete | train | def delete(self, query_name):
"""
Deletes a saved query from a project with a query name.
Master key must be set.
"""
| python | {
"resource": ""
} |
q14509 | UserAuth.get_auth | train | def get_auth(self):
"""Returns auth response which has client token unless MFA is required"""
auth_resp = get_with_retry(self.cerberus_url + '/v2/auth/user',
| python | {
"resource": ""
} |
q14510 | UserAuth.get_token | train | def get_token(self):
"""sets client token from Cerberus"""
auth_resp = self.get_auth()
if auth_resp['status'] == 'mfa_req':
token_resp = self.get_mfa(auth_resp)
else:
| python | {
"resource": ""
} |
q14511 | UserAuth.get_mfa | train | def get_mfa(self, auth_resp):
"""Gets MFA code from user and returns response which includes the client token"""
devices = auth_resp['data']['devices']
if len(devices) == 1:
# If there's only one option, don't show selection prompt
selection = "0"
x = 1
... | python | {
"resource": ""
} |
q14512 | _parse_standard_flag | train | def _parse_standard_flag(read_buffer, mask_length):
"""Construct standard flag, standard mask data from the file.
Specifically working on Reader Requirements box.
Parameters
----------
fptr : file object
File object for JP2K file.
mask_length : int
Length of standard mask flag
... | python | {
"resource": ""
} |
q14513 | _parse_vendor_features | train | def _parse_vendor_features(read_buffer, mask_length):
"""Construct vendor features, vendor mask data from the file.
Specifically working on Reader Requirements box.
Parameters
----------
fptr : file object
File object for JP2K file.
mask_length : int
Length of vendor mask flag
... | python | {
"resource": ""
} |
q14514 | Jp2kBox._dispatch_validation_error | train | def _dispatch_validation_error(self, msg, writing=False):
"""Issue either a warning or an error depending on circumstance.
If writing to file, then error | python | {
"resource": ""
} |
q14515 | Jp2kBox._indent | train | def _indent(self, textstr, indent_level=4):
"""
Indent a string.
Textwrap's indent method only exists for 3.3 or above. In 2.7 we have
to fake it.
Parameters
----------
textstring : str
String to be indented.
indent_level : str
N... | python | {
"resource": ""
} |
q14516 | Jp2kBox._write_superbox | train | def _write_superbox(self, fptr, box_id):
"""Write a superbox.
Parameters
----------
fptr : file or file object
Superbox (box of boxes) to be written to this file.
box_id : bytes
4-byte sequence that identifies the superbox.
"""
# Write the... | python | {
"resource": ""
} |
q14517 | Jp2kBox._parse_this_box | train | def _parse_this_box(self, fptr, box_id, start, num_bytes):
"""Parse the current box.
Parameters
----------
fptr : file
Open file object, currently points to start of box payload, not the
start of the box.
box_id : str
4-letter identifier for t... | python | {
"resource": ""
} |
q14518 | Jp2kBox.parse_superbox | train | def parse_superbox(self, fptr):
"""Parse a superbox (box consisting of nothing but other boxes.
Parameters
----------
fptr : file
Open file object.
Returns
-------
list
List of top-level boxes in the JPEG 2000 file.
"""
s... | python | {
"resource": ""
} |
q14519 | ColourSpecificationBox._write_validate | train | def _write_validate(self):
"""In addition to constructor validation steps, run validation steps
for writing."""
if self.colorspace is None:
msg = ("Writing colr boxes without enumerated "
"colorspaces is not supported at this time.")
| python | {
"resource": ""
} |
q14520 | ColourSpecificationBox.write | train | def write(self, fptr):
"""Write an Colour Specification box to file.
"""
self._write_validate()
length = 15 if self.icc_profile is None else 11 + len(self.icc_profile)
fptr.write(struct.pack('>I4s', length, b'colr'))
read_buffer = struct.pack('>BBBI',
... | python | {
"resource": ""
} |
q14521 | ColourSpecificationBox.parse | train | def parse(cls, fptr, offset, length):
"""Parse JPEG 2000 color specification box.
Parameters
----------
fptr : file
Open file object.
offset : int
Start position of box in bytes.
length : int
Length of the box in bytes.
Return... | python | {
"resource": ""
} |
q14522 | ChannelDefinitionBox.write | train | def write(self, fptr):
"""Write a channel definition box to file.
"""
self._validate(writing=True)
num_components = len(self.association)
fptr.write(struct.pack('>I4s', 8 + 2 + num_components * 6, b'cdef'))
fptr.write(struct.pack('>H', num_components))
for j in ra... | python | {
"resource": ""
} |
q14523 | ChannelDefinitionBox.parse | train | def parse(cls, fptr, offset, length):
"""Parse component definition box.
Parameters
----------
fptr : file
Open file object.
offset : int
Start position of box in bytes.
length : int
Length of the box in bytes.
Returns
... | python | {
"resource": ""
} |
q14524 | ColourGroupBox.write | train | def write(self, fptr):
"""Write a colour group box to file.
| python | {
"resource": ""
} |
q14525 | ComponentMappingBox.write | train | def write(self, fptr):
"""Write a Component Mapping box to file.
"""
length = 8 + 4 * len(self.component_index)
write_buffer = struct.pack('>I4s', length, b'cmap')
fptr.write(write_buffer)
| python | {
"resource": ""
} |
q14526 | ComponentMappingBox.parse | train | def parse(cls, fptr, offset, length):
"""Parse component mapping box.
Parameters
----------
fptr : file
Open file object.
offset : int
Start position of box in bytes.
length : int
Length of the box in bytes.
Returns
--... | python | {
"resource": ""
} |
q14527 | ContiguousCodestreamBox.parse | train | def parse(cls, fptr, offset=0, length=0):
"""Parse a codestream box.
Parameters
----------
fptr : file
Open file object.
offset : int
Start position of box in bytes.
length : int
Length of the box in bytes.
Returns
---... | python | {
"resource": ""
} |
q14528 | DataReferenceBox.write | train | def write(self, fptr):
"""Write a Data Reference box to file.
"""
self._write_validate()
# Very similar to the way a superbox is written.
orig_pos = fptr.tell()
fptr.write(struct.pack('>I4s', 0, b'dtbl'))
# Write the number of data entry url boxes.
write... | python | {
"resource": ""
} |
q14529 | DataReferenceBox.parse | train | def parse(cls, fptr, offset, length):
"""Parse data reference box.
Parameters
----------
fptr : file
Open file object.
offset : int
Start position of box in bytes.
length : int
Length of the box in bytes.
Returns
-----... | python | {
"resource": ""
} |
q14530 | FileTypeBox._validate | train | def _validate(self, writing=False):
"""
Validate the box before writing to file.
"""
if self.brand not in ['jp2 ', 'jpx ']:
msg = ("The file type brand was '{brand}'. "
"It should be either 'jp2 ' or 'jpx '.")
msg = msg.format(brand=self.brand)... | python | {
"resource": ""
} |
q14531 | FileTypeBox.write | train | def write(self, fptr):
"""Write a File Type box to file.
"""
self._validate(writing=True)
length = 16 + 4 * len(self.compatibility_list)
fptr.write(struct.pack('>I4s', length, b'ftyp'))
| python | {
"resource": ""
} |
q14532 | FileTypeBox.parse | train | def parse(cls, fptr, offset, length):
"""Parse JPEG 2000 file type box.
Parameters
----------
f : file
Open file object.
offset : int
Start position of box in bytes.
length : int
Length of the box in bytes.
Returns
---... | python | {
"resource": ""
} |
q14533 | FragmentListBox._validate | train | def _validate(self, writing=False):
"""Validate internal correctness."""
if (((len(self.fragment_offset) != len(self.fragment_length)) or
(len(self.fragment_length) != len(self.data_reference)))):
msg = ("The lengths of the fragment offsets ({len_offsets}), "
... | python | {
"resource": ""
} |
q14534 | FragmentListBox.write | train | def write(self, fptr):
"""Write a fragment list box to file.
"""
self._validate(writing=True)
num_items = len(self.fragment_offset)
length = 8 + 2 + num_items * 14
fptr.write(struct.pack('>I4s', length, b'flst'))
fptr.write(struct.pack('>H', num_items))
fo... | python | {
"resource": ""
} |
q14535 | FragmentTableBox._validate | train | def _validate(self, writing=False):
"""Self-validate the box before writing."""
box_ids = [box.box_id for box in self.box]
if len(box_ids) != 1 or box_ids[0] != 'flst':
| python | {
"resource": ""
} |
q14536 | FragmentTableBox.write | train | def write(self, fptr):
"""Write a fragment table box to file.
| python | {
"resource": ""
} |
q14537 | ImageHeaderBox.write | train | def write(self, fptr):
"""Write an Image Header box to file.
"""
fptr.write(struct.pack('>I4s', 22, b'ihdr'))
# signedness and bps are stored together in a single byte
bit_depth_signedness = 0x80 if self.signed else 0x00
bit_depth_signedness |= self.bits_per_component - ... | python | {
"resource": ""
} |
q14538 | ImageHeaderBox.parse | train | def parse(cls, fptr, offset, length):
"""Parse JPEG 2000 image header box.
Parameters
----------
fptr : file
Open file object.
offset : int
Start position of box in bytes.
length : int
Length of the box in bytes.
Returns
... | python | {
"resource": ""
} |
q14539 | BitsPerComponentBox.parse | train | def parse(cls, fptr, offset, length):
"""Parse bits per component box.
Parameters
----------
fptr : file
Open file object.
offset : int
Start position of box in bytes.
length : int
Length of the box in bytes.
Returns
-... | python | {
"resource": ""
} |
q14540 | JP2HeaderBox.parse | train | def parse(cls, fptr, offset, length):
"""Parse JPEG 2000 header box.
Parameters
----------
fptr : file
Open file object.
offset : int
Start position of box in bytes.
length : int
Length of the box in bytes.
Returns
---... | python | {
"resource": ""
} |
q14541 | JPEG2000SignatureBox.write | train | def write(self, fptr):
"""Write a JPEG 2000 Signature box to file.
| python | {
"resource": ""
} |
q14542 | JPEG2000SignatureBox.parse | train | def parse(cls, fptr, offset, length):
"""Parse JPEG 2000 signature box.
Parameters
----------
fptr : file
Open file object.
offset : int
Start position of box in bytes.
| python | {
"resource": ""
} |
q14543 | PaletteBox.write | train | def write(self, fptr):
"""Write a Palette box to file.
"""
self._validate(writing=True)
bytes_per_row = sum(self.bits_per_component) / 8
bytes_per_palette = bytes_per_row * self.palette.shape[0]
box_length = 8 + 3 + self.palette.shape[1] + bytes_per_palette
# Wri... | python | {
"resource": ""
} |
q14544 | PaletteBox.parse | train | def parse(cls, fptr, offset, length):
"""Parse palette box.
Parameters
----------
fptr : file
Open file object.
offset : int
Start position of box in bytes.
length : int
Length of the box in bytes.
Returns
-------
... | python | {
"resource": ""
} |
q14545 | ReaderRequirementsBox.parse | train | def parse(cls, fptr, offset, length):
"""Parse reader requirements box.
Parameters
----------
fptr : file
Open file object.
offset : int
Start position of box in bytes.
length : int
Length of the box in bytes.
Returns
... | python | {
"resource": ""
} |
q14546 | CaptureResolutionBox.parse | train | def parse(cls, fptr, offset, length):
"""Parse CaptureResolutionBox.
Parameters
----------
fptr : file
Open file object.
offset : int
Start position of box in bytes.
length : int
Length of the box in bytes.
Returns
---... | python | {
"resource": ""
} |
q14547 | LabelBox.write | train | def write(self, fptr):
"""Write a Label box to file.
"""
length = 8 + len(self.label.encode())
| python | {
"resource": ""
} |
q14548 | LabelBox.parse | train | def parse(cls, fptr, offset, length):
"""Parse Label box.
Parameters
----------
fptr : file
Open file object.
offset : int
Start position of box in bytes.
length : int
Length of the box in bytes.
Returns
-------
... | python | {
"resource": ""
} |
q14549 | NumberListBox.parse | train | def parse(cls, fptr, offset, length):
"""Parse number list box.
Parameters
----------
fptr : file
Open file object.
offset : int
Start position of box in bytes.
length : int
Length of the box in bytes.
Returns
-------
... | python | {
"resource": ""
} |
q14550 | NumberListBox.write | train | def write(self, fptr):
"""Write a NumberList box to file.
"""
fptr.write(struct.pack('>I4s',
len(self.associations) * 4 + 8, b'nlst'))
fmt = '>' + 'I' * | python | {
"resource": ""
} |
q14551 | XMLBox.write | train | def write(self, fptr):
"""
Write an XML box to file.
"""
read_buffer = ET.tostring(self.xml.getroot(), encoding='utf-8')
| python | {
"resource": ""
} |
q14552 | XMLBox.parse | train | def parse(cls, fptr, offset, length):
"""Parse XML box.
Parameters
----------
fptr : file
Open file object.
offset : int
Start position of box in bytes.
length : int
Length of the box in bytes.
Returns
-------
... | python | {
"resource": ""
} |
q14553 | UUIDListBox.write | train | def write(self, fptr):
"""Write a UUID list box to file.
"""
num_uuids = len(self.ulst)
length = 4 + 4 + 2 + num_uuids * 16
write_buffer = struct.pack('>I4sH', length, b'ulst', | python | {
"resource": ""
} |
q14554 | UUIDListBox.parse | train | def parse(cls, fptr, offset, length):
"""Parse UUIDList box.
Parameters
----------
f : file
Open file object.
offset : int
Start position of box in bytes.
length : int
Length of the box in bytes.
Returns
-------
... | python | {
"resource": ""
} |
q14555 | DataEntryURLBox.write | train | def write(self, fptr):
"""Write a data entry url box to file.
"""
# Make sure it is written out as null-terminated.
url = self.url
if self.url[-1] != chr(0):
url = url + chr(0)
url = url.encode()
length = 8 + 1 + 3 + len(url)
write_buffer = st... | python | {
"resource": ""
} |
q14556 | DataEntryURLBox.parse | train | def parse(cls, fptr, offset, length):
"""Parse data entry URL box.
Parameters
----------
fptr : file
Open file object.
offset : int
Start position of box in bytes.
length : int
Length of the box in bytes.
Returns
-----... | python | {
"resource": ""
} |
q14557 | UUIDBox._parse_raw_data | train | def _parse_raw_data(self):
"""
Private function for parsing UUID payloads if possible.
"""
if self.uuid == _XMP_UUID:
txt = self.raw_data.decode('utf-8')
elt = ET.fromstring(txt)
self.data = ET.ElementTree(elt)
elif self.uuid == _GEOTIFF_UUID:
... | python | {
"resource": ""
} |
q14558 | UUIDBox._print_geotiff | train | def _print_geotiff(self):
"""
Print geotiff information. Shamelessly ripped off from gdalinfo.py
Returns
-------
str
String representation of the degenerate geotiff.
"""
if self.data is None:
return "corrupt"
in_mem_name = '/vsime... | python | {
"resource": ""
} |
q14559 | UUIDBox.write | train | def write(self, fptr):
"""Write a UUID box to file.
"""
length = 4 + 4 + 16 + len(self.raw_data)
write_buffer = struct.pack('>I4s', length, b'uuid')
| python | {
"resource": ""
} |
q14560 | UUIDBox.parse | train | def parse(cls, fptr, offset, length):
"""Parse UUID box.
Parameters
----------
fptr : file
Open file object.
offset : int
Start position of box in bytes.
length : int
Length of the box in bytes.
Returns
-------
... | python | {
"resource": ""
} |
q14561 | _parse_precinct_size | train | def _parse_precinct_size(spcod):
"""Compute precinct size from SPcod or SPcoc."""
spcod = np.frombuffer(spcod, dtype=np.uint8)
precinct_size = []
for item in spcod:
ep2 = (item & 0xF0) >> 4
| python | {
"resource": ""
} |
q14562 | _context_string | train | def _context_string(context):
"""Produce a string to represent the code block context"""
msg = 'Code block context:\n '
lines = ['Selective arithmetic coding bypass: {0}',
'Reset context probabilities on coding pass boundaries: {1}',
'Termination on each coding pass: ... | python | {
"resource": ""
} |
q14563 | parse_quantization | train | def parse_quantization(read_buffer, sqcd):
"""Tease out the quantization values.
Parameters
----------
read_buffer: sequence of bytes from the QCC and QCD segments.
Returns
------
tuple
Mantissa and exponents from quantization buffer.
"""
numbytes = len(read_buffer)
... | python | {
"resource": ""
} |
q14564 | _print_quantization_style | train | def _print_quantization_style(sqcc):
"""Only to be used with QCC and QCD segments."""
msg = '\n Quantization style: '
if sqcc & 0x1f == 0:
msg += 'no quantization, '
elif sqcc & 0x1f == 1:
| python | {
"resource": ""
} |
q14565 | Codestream._parse_unrecognized_segment | train | def _parse_unrecognized_segment(self, fptr):
"""Looks like a valid marker, but not sure from reading the specs.
"""
msg = ("Unrecognized codestream marker 0x{marker_id:x} encountered at "
"byte offset {offset}.")
msg = msg.format(marker_id=self._marker_id, offset=fptr.tell... | python | {
"resource": ""
} |
q14566 | Codestream._parse_reserved_segment | train | def _parse_reserved_segment(self, fptr):
"""Parse valid marker segment, segment description is unknown.
Parameters
----------
fptr : file object
The file to parse.
Returns
-------
Segment
The current segment.
"""
offset = ... | python | {
"resource": ""
} |
q14567 | Codestream._parse_tile_part_bit_stream | train | def _parse_tile_part_bit_stream(self, fptr, sod_marker, tile_length):
"""Parse the tile part bit stream for SOP, EPH marker segments."""
read_buffer = fptr.read(tile_length)
# The tile length could possibly be too large and extend past
# the end of file. We need to be a bit resilient.
... | python | {
"resource": ""
} |
q14568 | Codestream._parse_cme_segment | train | def _parse_cme_segment(self, fptr):
"""Parse the CME marker segment.
Parameters
----------
fptr : file
Open file object.
Returns
-------
CMESegment
The current CME segment.
"""
offset = fptr.tell() | python | {
"resource": ""
} |
q14569 | Codestream._parse_coc_segment | train | def _parse_coc_segment(self, fptr):
"""Parse the COC marker segment.
Parameters
----------
fptr : file
Open file object.
Returns
-------
COCSegment
The current COC segment.
"""
kwargs = {}
offset = fptr.tell() - 2
... | python | {
"resource": ""
} |
q14570 | Codestream._parse_cod_segment | train | def _parse_cod_segment(cls, fptr):
"""Parse the COD segment.
Parameters
----------
fptr : file
Open file object.
Returns
-------
CODSegment
The current COD segment.
"""
offset = fptr.tell() - 2
read_buffer = fptr.... | python | {
"resource": ""
} |
q14571 | Codestream._parse_crg_segment | train | def _parse_crg_segment(self, fptr):
"""Parse the CRG marker segment.
Parameters
----------
fptr : file
Open file object.
Returns
-------
CRGSegment
The current CRG segment.
"""
offset = fptr.tell() - 2
read_buffer... | python | {
"resource": ""
} |
q14572 | Codestream._parse_plt_segment | train | def _parse_plt_segment(self, fptr):
"""Parse the PLT segment.
The packet headers are not parsed, i.e. they remain uninterpreted raw
data buffers.
Parameters
----------
fptr : file
Open file object.
Returns
-------
PLTSegment
... | python | {
"resource": ""
} |
q14573 | Codestream._parse_pod_segment | train | def _parse_pod_segment(self, fptr):
"""Parse the POD segment.
Parameters
----------
fptr : file
Open file object.
Returns
-------
PODSegment
The current POD segment.
"""
offset = fptr.tell() - 2
read_buffer = fptr... | python | {
"resource": ""
} |
q14574 | Codestream._parse_ppm_segment | train | def _parse_ppm_segment(self, fptr):
"""Parse the PPM segment.
Parameters
----------
fptr : file
Open file object.
Returns
-------
PPMSegment
The current PPM segment.
"""
offset = fptr.tell() | python | {
"resource": ""
} |
q14575 | Codestream._parse_ppt_segment | train | def _parse_ppt_segment(self, fptr):
"""Parse the PPT segment.
The packet headers are not parsed, i.e. they remain "uninterpreted"
raw data beffers.
Parameters
----------
fptr : file object
The file to parse.
Returns
-------
PPTSegmen... | python | {
"resource": ""
} |
q14576 | Codestream._parse_qcc_segment | train | def _parse_qcc_segment(cls, fptr):
"""Parse the QCC segment.
Parameters
----------
fptr : file object
The file to parse.
Returns
-------
QCCSegment
The current QCC segment.
"""
offset = fptr.tell() - 2
read_buffer... | python | {
"resource": ""
} |
q14577 | Codestream._parse_qcd_segment | train | def _parse_qcd_segment(self, fptr):
"""Parse the QCD segment.
Parameters
----------
fptr : file
Open file object.
Returns
-------
| python | {
"resource": ""
} |
q14578 | Codestream._parse_rgn_segment | train | def _parse_rgn_segment(cls, fptr):
"""Parse the RGN segment.
Parameters
----------
fptr : file
Open file object.
Returns
-------
RGNSegment
The current RGN segment.
"""
offset = fptr.tell() - 2
| python | {
"resource": ""
} |
q14579 | Codestream._parse_sot_segment | train | def _parse_sot_segment(self, fptr):
"""Parse the SOT segment.
Parameters
----------
fptr : file
Open file object.
Returns
-------
SOTSegment
The current SOT segment.
"""
offset = fptr.tell() - 2
read_buffer = fptr... | python | {
"resource": ""
} |
q14580 | Codestream._parse_tlm_segment | train | def _parse_tlm_segment(self, fptr):
"""Parse the TLM segment.
Parameters
----------
fptr : file
Open file object.
Returns
-------
TLMSegment
The current TLM segment.
"""
offset = fptr.tell() - 2
read_buffer = fptr... | python | {
"resource": ""
} |
q14581 | Codestream._parse_reserved_marker | train | def _parse_reserved_marker(self, fptr):
"""Marker range between 0xff30 and 0xff39.
"""
the_id = '0x{0:x}'.format(self._marker_id)
| python | {
"resource": ""
} |
q14582 | Event.to_json | train | def to_json(self):
""" Serializes the event to JSON.
:returns: a string
"""
event_as_dict = copy.deepcopy(self.event_body)
if self.timestamp:
if "keen" in event_as_dict:
event_as_dict["keen"]["timestamp"] = self.timestamp.isoformat()
| python | {
"resource": ""
} |
q14583 | KeenClient.delete_events | train | def delete_events(self, event_collection, timeframe=None, timezone=None, filters=None):
""" Deletes events.
:param event_collection: string, the event collection from which event are being deleted
:param timeframe: string or dict, the timeframe in which the events happened
example: "pre... | python | {
"resource": ""
} |
q14584 | KeenClient._base64_encode | train | def _base64_encode(self, string_to_encode):
""" Base64 encodes a string, with either Python 2 or 3.
:param string_to_encode: the string to encode
"""
try:
# python 2
return base64.b64encode(string_to_encode)
except TypeError:
| python | {
"resource": ""
} |
q14585 | KeenClient.select_unique | train | def select_unique(self, event_collection, target_property, timeframe=None, timezone=None, interval=None,
filters=None, group_by=None, order_by=None, max_age=None, limit=None):
""" Performs a select unique query
Returns an array of the unique values of a target property for events ... | python | {
"resource": ""
} |
q14586 | KeenClient.funnel | train | def funnel(self, steps, timeframe=None, timezone=None, max_age=None, all_keys=False):
""" Performs a Funnel query
Returns an object containing the results for each step of the funnel.
:param steps: array of dictionaries, one for each step. example:
[{"event_collection":"signup","actor_... | python | {
"resource": ""
} |
q14587 | cio_open | train | def cio_open(cinfo, src=None):
"""Wrapper for openjpeg library function opj_cio_open."""
argtypes = [ctypes.POINTER(CommonStructType), ctypes.c_char_p,
ctypes.c_int]
OPENJPEG.opj_cio_open.argtypes = argtypes
OPENJPEG.opj_cio_open.restype = ctypes.POINTER(CioType)
if src is None:
... | python | {
"resource": ""
} |
q14588 | cio_close | train | def cio_close(cio):
"""Wraps openjpeg library function cio_close.
"""
| python | {
"resource": ""
} |
q14589 | cio_tell | train | def cio_tell(cio):
"""Get position in byte stream."""
OPENJPEG.cio_tell.argtypes | python | {
"resource": ""
} |
q14590 | create_compress | train | def create_compress(fmt):
"""Wrapper for openjpeg library function opj_create_compress.
Creates a J2K/JPT/JP2 compression structure.
| python | {
"resource": ""
} |
q14591 | create_decompress | train | def create_decompress(fmt):
"""Wraps openjpeg library function opj_create_decompress.
"""
OPENJPEG.opj_create_decompress.argtypes = [ctypes.c_int]
restype = ctypes.POINTER(DecompressionInfoType) | python | {
"resource": ""
} |
q14592 | decode | train | def decode(dinfo, cio):
"""Wrapper for opj_decode.
"""
argtypes = [ctypes.POINTER(DecompressionInfoType), ctypes.POINTER(CioType)]
OPENJPEG.opj_decode.argtypes = argtypes
| python | {
"resource": ""
} |
q14593 | destroy_compress | train | def destroy_compress(cinfo):
"""Wrapper for openjpeg library function opj_destroy_compress.
Release resources for a compressor handle.
"""
argtypes = [ctypes.POINTER(CompressionInfoType)]
| python | {
"resource": ""
} |
q14594 | encode | train | def encode(cinfo, cio, image):
"""Wrapper for openjpeg library function opj_encode.
Encodes an image into a JPEG-2000 codestream.
Parameters
----------
cinfo : compression handle
cio : output buffer stream
image : image to encode
"""
argtypes = [ctypes.POINTER(CompressionInfoType... | python | {
"resource": ""
} |
q14595 | destroy_decompress | train | def destroy_decompress(dinfo):
"""Wraps openjpeg library function opj_destroy_decompress."""
| python | {
"resource": ""
} |
q14596 | image_create | train | def image_create(cmptparms, cspace):
"""Wrapper for openjpeg library function opj_image_create.
"""
lst = [ctypes.c_int, ctypes.POINTER(ImageComptParmType), ctypes.c_int]
OPENJPEG.opj_image_create.argtypes = lst
| python | {
"resource": ""
} |
q14597 | image_destroy | train | def image_destroy(image):
"""Wraps openjpeg library function opj_image_destroy."""
| python | {
"resource": ""
} |
q14598 | set_default_encoder_parameters | train | def set_default_encoder_parameters():
"""Wrapper for openjpeg library function opj_set_default_encoder_parameters.
"""
cparams = CompressionParametersType()
argtypes = [ctypes.POINTER(CompressionParametersType)]
| python | {
"resource": ""
} |
q14599 | set_default_decoder_parameters | train | def set_default_decoder_parameters(dparams_p):
"""Wrapper for opj_set_default_decoder_parameters.
"""
argtypes = [ctypes.POINTER(DecompressionParametersType)]
| python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.