_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 75 19.8k | 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 tag. Just use the ... | 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.
"""
response = self._get_json(HTTPMethods.GET, self.saved_query_url, self._get_master_key())
return response | 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.
"""
url = "{0}/{1}".format(self.saved_query_url, query_name)
response = self._get_json(HTTPMethods.GET, url, self._get_master_k... | 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 = "{0}/{1}/result".format(self.saved_query_url, query_name)
response = self._get_jso... | 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.
"""
url = "{0}/{1}".format(self.saved_query_url, query_name)
self._get_json(HTTPMethods.DELETE, url, self._get_master_key())
return True | 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',
auth=(self.username, self.password),
headers=self.HEADERS)
if auth_resp... | 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:
token_resp = auth_resp
token = token_resp['data']['client_token']['client_token']
... | 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 out, as we do not wish to create bad
JP2 files. If reading, then we should be more lenient and just warn.
"""
if writing:
... | 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.")
self._dispatch_vali... | 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.
"""
self._validate(writing=True)
self._write_superbox(fptr, b'cgrp') | 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)
for j in range(len(self.component_index)):
write_buffer = struct.pack(... | 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'))
fptr.write(self.brand.encode())
fptr.write(struct.pack('>I', self.minor_versio... | 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':
msg = ("Fragment table boxes must have a single fragment list "
"box as a child box.")
... | python | {
"resource": ""
} |
q14536 | FragmentTableBox.write | train | def write(self, fptr):
"""Write a fragment table box to file.
"""
self._validate(writing=True)
self._write_superbox(fptr, b'ftbl') | 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.
"""
fptr.write(struct.pack('>I4s', 12, b'jP '))
fptr.write(struct.pack('>BBBB', *self.signature)) | 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.
length : int
Length of the box in bytes.
Returns
... | 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())
fptr.write(struct.pack('>I4s', length, b'lbl '))
fptr.write(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' * len(self.associations)
write_buffer = struct.pack(fmt, *self.associations)
fptr.write(w... | 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')
fptr.write(struct.pack('>I4s', len(read_buffer) + 8, b'xml '))
fptr.write(read_buffer) | 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', num_uuids)
fptr.write(write_buffer)
for j in range(num_uuids):
fptr.write(... | 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')
fptr.write(write_buffer)
fptr.write(self.uuid.bytes)
fptr.write(self.raw_data) | 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
ep1 = item & 0x0F
precinct_size.append((2 ** ep1, 2 ** ep2))
return tuple(precinct_siz... | 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:
msg += 'scalar implicit, '
elif sqcc & 0x1f == 2:
msg += 'scalar explicit, '
r... | 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() - 2
read_buffer... | 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() - 2
read_buffer = fptr... | 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
-------
QCDSegment
The current QCD segment.
"""
offset = fptr.tell() - 2
read_buffer = fptr... | 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
read_buffer = fptr.... | 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)
segment = Segment(marker_id=the_id, offset=self._offset, length=0)
return segment | 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()
else:... | 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 3
... | 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.
"""
OPENJPEG.opj_cio_close.argtypes = [ctypes.POINTER(CioType)]
OPENJPEG.opj_cio_close(cio) | python | {
"resource": ""
} |
q14589 | cio_tell | train | def cio_tell(cio):
"""Get position in byte stream."""
OPENJPEG.cio_tell.argtypes = [ctypes.POINTER(CioType)]
OPENJPEG.cio_tell.restype = ctypes.c_int
pos = OPENJPEG.cio_tell(cio)
return pos | 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.
"""
OPENJPEG.opj_create_compress.argtypes = [ctypes.c_int]
OPENJPEG.opj_create_compress.restype = ctypes.POINTER(CompressionInfoType)
cinfo = OPENJPEG.opj_create_... | 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)
OPENJPEG.opj_create_decompress.restype = restype
dinfo = OPENJPEG.opj_create_decompress(fmt)
retu... | 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
OPENJPEG.opj_decode.restype = ctypes.POINTER(ImageType)
image = OPENJPEG.opj_decode(dinfo, cio)
return image | 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)]
OPENJPEG.opj_destroy_compress.argtypes = argtypes
OPENJPEG.opj_destroy_compress(cinfo) | 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."""
argtypes = [ctypes.POINTER(DecompressionInfoType)]
OPENJPEG.opj_destroy_decompress.argtypes = argtypes
OPENJPEG.opj_destroy_decompress(dinfo) | 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
OPENJPEG.opj_image_create.restype = ctypes.POINTER(ImageType)
image = OPENJPEG.opj_... | python | {
"resource": ""
} |
q14597 | image_destroy | train | def image_destroy(image):
"""Wraps openjpeg library function opj_image_destroy."""
OPENJPEG.opj_image_destroy.argtypes = [ctypes.POINTER(ImageType)]
OPENJPEG.opj_image_destroy(image) | 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)]
OPENJPEG.opj_set_default_encoder_parameters.argtypes = argtypes
OPENJPEG.opj_set_def... | 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)]
OPENJPEG.opj_set_default_decoder_parameters.argtypes = argtypes
OPENJPEG.opj_set_default_decoder_parameters(dparams_p) | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.