content stringlengths 42 6.51k |
|---|
def bytes2str(string):
"""Converts b'...' string into '...' string. On PY2 they are equivalent. On PY3 its utf8 decoded."""
return string.decode("utf8") |
def get_media_pool_items(track_items):
"""Return media pool items for all track items"""
all_media_pool_items = []
for track in track_items:
for item in track:
media_item = item.GetMediaPoolItem()
all_media_pool_items.append(media_item)
return all_media_pool_items |
def NamesOfDefinedFlags():
"""Returns: List of names of the flags declared in this module."""
return ['tmod_bar_x',
'tmod_bar_y',
'tmod_bar_z',
'tmod_bar_t',
'tmod_bar_u',
'tmod_bar_v'] |
def sub(num1:int,num2:int) -> int:
"""sub is function used to give the subtraction
of two inputted number
if num1 is greater than num2 then returns num1 - num2
else
num2 - num1
Args:
num1 (int): first number
num2 (int): second number
Returns:
int: subtra... |
def GetContigs(orthologs):
"""get map of contigs to orthologs.
An ortholog can be part of only one contig, but the same ortholog_id can
be part of several contigs.
"""
contigs = {}
for id, oo in orthologs.items():
for o in oo:
if o.contig not in contigs:
con... |
def unpack_list_of_tuples(list_tuples):
"""takes the list of tuples e.g
[("A","B),("C","D)] and unpacks them into a normal list
like ["A","B","C","D]
Args:
list_tuples ([list]): [description]
Returns:
[text]: [list] the untupled list
"""
text=[]
for i in range(len(list... |
def parse_pid(s):
"""Convert processID as string to integer.
The string may be suffixed with a status code which
is discarded.
"""
try:
pid = int(s)
except ValueError:
pid = int(s[:-1])
return pid |
def lerp(a, b, x):
"""Linear interpolation."""
return a + x * (b - a) |
def bytes_to_little_int(data: bytearray) -> int:
"""Convert bytes to little int."""
return int.from_bytes(data, byteorder="little", signed=False) |
def str2bool(v):
"""[ because argparse does not support to parse "true, False" as python
boolean directly]
Arguments:
v {[type]} -- [description]
Returns:
[type] -- [description]
"""
return v.lower() in ("true", "t", "1") |
def glib2fsnative(path):
"""Convert glib to native filesystem format"""
assert isinstance(path, bytes)
return path |
def is_compmap(name):
"""
Tf2 maps have prefixes which tell the map types. Control points (cp_),
payload (pl), and king of the hill (koth_), are the only map types
played competitively.
"""
return name.startswith("cp_") or name.startswith("pl_") or name.startswith(
"koth_") |
def sort_by_index(index, array):
"""
Sort the array with the given index and return a list of
(<element>, <original index>, <new index>) tuples. Throw an assertion
error (thrown by failed asserts automatically) if the arguments passed
are invalid.
>>> sort_by_index([ 0, 4, 2, 3, 1], \
["zero", ... |
def cleanup_threshold(amp=False, cleanup=False) -> float:
"""Determine the appropriate cleanup threshold value to use in amp or power
Args:
amp: input TIF is in amplitude and not power
cleanup: Cleanup artifacts using a -48 db power threshold
Returns:
clean_threshold: the cleaning ... |
def int_(num: str) -> int:
"""
Take an integer in the form of a string, remove any commas from it,
then return it as an ``int``.
Args:
num: A string containing only numeric characters or commas.
Returns:
An integer version of the string.
"""
return int(num.replace(",", "")) |
def get_doc_data(gold_summ_docs):
"""
This function takes in a list of gold summary Document objects
and returns a dictionary of the data.
Keys are document object and values are list of tuples of (sent, set of nouns)
for each sent in the doc. {doc_obj: [(sent_index, sent_noun_set)]
"""
do... |
def type_analysis(year):
"""
Takes a valid year and outputs its type (Leap, later, middle, previous ou anomalous).
:param year: the year to analyze.
:return: binary list with the year type (string) and its list index (0-4).
"""
types = ['Leap', 'Later', 'Middle', 'Previous', 'Anomalous']
... |
def check_callable(input_func, min_num_args=2):
"""Ensures the input func 1) is callable, and 2) can accept a min # of args"""
if not callable(input_func):
raise TypeError('Input function must be callable!')
from inspect import signature
# would not work for C/builtin functions such as numpy.d... |
def triplicar_letra(i,j,nivel):
"""Verifica si el casillero es de triplicar el puntaje de la letra"""
if nivel == "facil":
if (i == 5 and j == 2) or (i == 2 and j == 5) or (i == 2 and j == 9) or (i == 5 and j == 12) or (i == 9 and j == 2) or (i == 12 and j == 5) or (i == 9 and j == 12) or (i == 12 and... |
def Getp2(M_0, M_1, M_2):
"""
Consider a two-body decay :math:`M_0\\rightarrow M_1M_2`. In the rest frame of :math:`M_0`, the momentum of
:math:`M_1` and :math:`M_2` are definite.
:param M_0: The invariant mass of :math:`M_0`
:param M_1: The invariant mass of :math:`M_1`
:param M_2: The invaria... |
def ordinal(num):
"""Returns the ordinal number of a given integer, as a string.
E.g. 1 -> 1st, 2 -> 2nd, 3 -> 3rd, etc."""
if 10 <= num % 100 < 20:
return '{0}th'.format(num)
else:
ord = {1: 'st', 2: 'nd', 3: 'rd'}.get(num % 10, 'th')
return '{0}{1}'.format(num, ord)
# end ... |
def namenumval(name):
"""Calculate the 'numeric value' of a name (by JM Zelle)."""
val = 0
alphabet = "abcdefghijklmnopqrstuvwxyz"
for char in name.lower().replace(" ", ""):
val += alphabet.find(char) + 1
return val |
def is_none_or_empty(_object):
"""
Tests if an object is none or empty
Parameters
----------
- object: a python object
"""
object_is_empty = isinstance(_object, list) and len(_object) == 0
return _object is None or object_is_empty |
def parse_port_range(port_range_or_num):
"""Parses a port range formatted as 'N', 'N-M', or 'all', where
N and M are integers, into a minimum and maximum port tuple."""
if port_range_or_num.lower() == 'all':
return 0, 65535
try:
port = int(port_range_or_num)
return port, port
... |
def GetGTestOutput(args):
"""Extracts gtest_output from the args. Returns none if not present."""
for arg in args:
if '--gtest_output=' in arg:
return arg.split('=')[1]
return None |
def parseReferences(dStr):
"""
Parse comma separated list of component references to a list
"""
return [x.strip() for x in dStr.split(",") if len(x.strip()) > 0] |
def sort_into_bucket(val, bucket_lbs):
"""
Returns the highest bucket such that val >= lower bound for that bucket.
Inputs:
val: float. The value to be sorted into a bucket.
bucket_lbs: list of floats, sorted ascending.
Returns:
bucket_id: int in range(num_buckets); the bucket that v... |
def right(state):
"""Shift state right
-Other move methods are based on the move right method"""
start = state
new = []
changed = True
for row in state:
new_row = []
new_row.append([tile for tile in row if tile != 0])
new.append([0]*(4-len(new_row[0]))+new_row[0])
sta... |
def vector_is_zero(vector_in, tol=10e-8):
""" Checks if the input vector is a zero vector.
:param vector_in: input vector
:type vector_in: list, tuple
:param tol: tolerance value
:type tol: float
:return: True if the input vector is zero, False otherwise
:rtype: bool
"""
if not isin... |
def group_svg(svg, offset: float = 0):
"""Wrap <g> tag for the svg
Args:
offset: The width offset in the whole reaction
Returns:
str: Grouped SVG string (without header)
"""
if offset == 0:
first_part = ''
else:
first_part = ' transform="translate({})"'.format(of... |
def extract_title_from_text(text: str) -> str:
"""Extract and return the title line from a text written in Markdown.
Returns the first line of the original text, minus any header markup ('#') at the start
of the line.
"""
firstline = text.split('\n', 1)[0]
return firstline.lstrip('# ') |
def runs(runs: list) -> dict:
"""Generate Github runs like dict."""
return {"total_count": len(runs), "workflow_runs": runs} |
def combinations(c, d):
"""
Compute all combinations possible between c and d and their derived values.
"""
c_list = [c-0.1, c, c+0.1]
d_list = [d-0.1, d, d+0.1]
possibilities = []
for cl in c_list:
for dl in d_list:
possibilities.append([cl, dl])
return possibilities |
def bioenergeticyield_kjhexoseperkJenergy(PAR, losspigmentantenna, quantumyield,
lossvoltagejump, losstoATPNADPH,
losstohexose, lossrespiration):
"""Returns the maximum theoretical amount of kJ stored as hexose per kJ
of sola... |
def remove_duplicates(nums):
"""Remove duplicated from a sorted array.
Given a sorted array nums, remove the duplicates in-place such that each element appears only once
and returns the new length.
Do not allocate extra space for another array,
you must do this by modifying the input array in-place ... |
def _format_sign(is_negative, spec):
"""Determine sign character."""
if is_negative:
return '-'
elif spec['sign'] in ' +':
return spec['sign']
else:
return '' |
def unpack_first_arg(data):
"""XXX
:param data:
:return:
"""
pos = data.find(b'\0')
pos = pos if pos > 0 else len(data)
head = data[:pos]
rest = data[pos+1:]
return head, rest |
def get_display_name(record):
"""Get the display name for a record.
Args:
record
A record returned by AWS.
Returns:
A display name for the task.
"""
name = record.get("startedBy")
if not name:
name = "Unnamed"
return str(name) + " (" + str(record["task... |
def _build_criteria(
deleted=False,
unread=False,
sent_from=False,
sent_to=False,
date_gt=False,
date_lt=False):
"""Builds the criteria list for an IMAP search call.
:param deleted: Include deleted messages.
:param unread: Include only unread messages.
:p... |
def eh_posicao (unidade):
"""Esta funcao indica se o argumento dado eh uma posicao \
nas condicoes descritas no enunciado do projeto"""
valor_logico4 = True
if type(unidade) != tuple: #Verifica se a unidade e um tuplo
valor_logico4 = False
elif len(unidade) != 2: #Verifica se o tuplo c... |
def fmt_xpath_spec(tag: str, attributes: dict):
"""Format a xpath_spec string using the given tag and attributes
The xpath_spec returned is 'absolute', and thus can't be used. Prepend "./" to the xpath spec if using it to
actually look up an element.
:param tag: The tag to format into the xpath ... |
def countMatches(items, ruleKey, ruleValue):
"""
:type items: List[List[str]]
:type ruleKey: str
:type ruleValue: str
:rtype: int
"""
count = 0
ruleDict = {
"type": 0,
"color": 1,
"name": 2
}
for i in items:
if i[ruleDict[ruleKey]] == ruleValue:
... |
def has_bingo(board):
"""
Checks if a board has won by checking if all of a particular row or column has None values.
:param board: List[List[str]]
:return: bool
"""
# Assume the dimension of the board to be 5x5 (given)
for row in board:
if all([x is None for x in row]):
... |
def length(list_a: list):
"""Problem 4: Find the number of Elements of a List.
Parameters
----------
list_a : list
The input list
Returns
-------
integer
The length of the input list
Raises
------
TypeError
If the given argument is not of `list` type
... |
def consult(string_in):
"""
provide file:consult/1 functionality with python types
"""
# pylint: disable=eval-used
# pylint: disable=too-many-branches
# pylint: disable=too-many-statements
# manually parse textual erlang data to avoid external dependencies
list_out = []
tuple_binary... |
def pad_msg16(msg):
"""Pad message with space to the nearest length of multiple of 16."""
pads = (16 - (len(msg) & 0xF)) & 0xF
return msg + b' ' * pads |
def use_ret_path(session):
"""Return and delete return path from session `session` if it exists"""
if 'ret_path' in session:
ret_path = session['ret_path']
del session['ret_path']
else:
ret_path = None
return ret_path |
def __rm_self(func, items):
"""Return the "See Also" section with the current function removed."""
ret = [i[1] for i in items if i[0] != func]
return 'See Also\n --------\n ' + '\n'.join(ret).lstrip() + '\n' |
def remove_dict_key(d, key, inplace=True):
"""
delete some key in dict
inplace = True : delete in origin dict
"""
if inplace:
new_d = d.copy()
try:
del new_d[key]
except KeyError:
pass
return new_d
else:
try:
del d[key... |
def get_p_survival(block=0, nb_total_blocks=110, p_survival_end=0.5, mode='linear_decay'):
"""
See eq. (4) in stochastic depth paper: http://arxiv.org/pdf/1603.09382v1.pdf
"""
if mode == 'uniform':
return p_survival_end
elif mode == 'linear_decay':
return 1 - ((block + 1) / nb_total_... |
def get_expstart(header, primary_hdr):
"""shouldn't this just be defined in the instrument subclass of imageobject?"""
if 'expstart' in primary_hdr:
exphdr = primary_hdr
else:
exphdr = header
if 'EXPSTART' in exphdr:
expstart = float(exphdr['EXPSTART'])
expend = float(e... |
def remove_comments_from_src(src):
"""
This reads tokens using tokenize.generate_tokens and recombines them
using tokenize.untokenize, and skipping comment/docstring tokens in between
"""
lines = src.split("\n")
new_lines = [x for x in lines if len(
x.strip()) > 0 and x.strip()[0] != "#"... |
def saveForwardState(old_s_tree, new_s_tree, s):
"""Saving the s_current as well as all its successors in the old_s_tree into the new_s_tree.
Parameters
----------
old_s_tree : dict
The old tree.
new_s_tree : dict
The new tree.
s_current : :py:class:`ast_toolbox.mcts.AdaptiveStr... |
def parse(m):
"""parse parses an HTTP message into 3 parts: first line, headers, body."""
while m.startswith('HTTP/1.1 100 Continue\r\n'):
m = m[m.find('\r\n\r\n')+4:]
p = m.find('\r\n')
if p == -1:
return
first = m[:p]
q = m.find('\r\n\r\n')
headers = m[p+2:q]
body = m[q+4:]
return first, hea... |
def cubic_easeout(pos):
"""
Easing function for animations: Cubic Ease Out
"""
fos = pos - 1
return fos * fos * fos + 1 |
def normalize_description(description):
"""
Normalizes a docstrings.
Parameters
----------
description : `str` or `Any`
The docstring to clear.
Returns
-------
cleared : `str` or `Any`
The cleared docstring. If `docstring` was given as `None` or is detected as e... |
def check_dht_value_type(value):
"""
Checks to see if the type of the value is a valid type for
placing in the dht.
"""
typeset = [
int,
float,
bool,
str,
bytes
]
return type(value) in typeset |
def arrRotation(x: list,d: int):
"""
The given function is first is first appending the elements to another array
till which the index is given, then removing those element from the given array
then appending the elements of the another array to the given array.
"""
arr = []
for i in range(0... |
def is_quoted_retweet(text):
"""
Determines if the text begins with a quoted retweet
:param text: The text to analyze (str)
:return: true | false
"""
return int(text[:2] == '"@') |
def partition_horizontal(thelist, n):
"""
Break a list into ``n`` peices, but "horizontally." That is,
``partition_horizontal(range(10), 3)`` gives::
[[1, 2, 3],
[4, 5, 6],
[7, 8, 9],
[10]]
Clear as mud?
"""
try:
n = int(n)
thelist = list(thel... |
def string_not(str1):
"""Apply logical 'not' to every symbol of string"""
return "".join([chr(256 + ~ord(x)) for x in str1]) |
def translate_shape(shp):
"""
translate shp into [#ag0,#ag1,#ag2]
"""
shp_temp = []
for i in range(0,len(shp)):
if type(shp[i]) == tuple:
shp_temp.append(shp[i][0]*shp[i][1])
else:
shp_temp.append(shp[i])
return shp_temp |
def snake_to_camel(string: str) -> str:
"""Convert from snake_case to camelCase."""
return "".join(
word.capitalize() if idx > 0 else word
for idx, word in enumerate(string.split("_"))
) |
def sdfChangeTitle(mol, newtitle):
"""
sdfChangeTitle() returns mol with title newtitle
"""
molblock = mol["molblock"]
if not molblock:
return None
first_eol_pos = molblock.find('\n')
molblock = newtitle + molblock[first_eol_pos:]
mol["molblock"] = molblock
return mol |
def is_testcase(func):
"""
Returns true if the given function is a testcase.
:param func: Function object.
:return: True if the function is decorated with testcase.
"""
return hasattr(func, '__testcase__') |
def date_parser(dates):
"""date_parser(dates)
Return a list of Date strings.
Parameters
----------
(list): list of datetime strings (REQUIRED)
Return
------
(list): list of Date strings.
Examples
-------
>>>dates = ['2019-11-29 12:50:54',
'201... |
def checkRows(board: list) -> bool:
"""
Returns True if there is no repeating numbers in the rows.
"""
for row in board:
numbersRow = row.replace('*', '').replace(' ', '')
if len(numbersRow) != len(set(numbersRow)):
return False
return True |
def filter_dict(d, cb):
"""
Filter a dictionary based on passed function.
:param d: The dictionary to be filtered
:param cb: A function which is called back for each k, v pair of the dictionary. Should return Truthy or Falsey
:return: The filtered dictionary (new instance)
"""
return {k: v... |
def which(program):
"""
Test to make sure that the program is executable
"""
import os
def is_exe(fpath):
return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
fpath, fname = os.path.split(program)
if fpath:
if is_exe(program):
return program
else:
... |
def puzzle_hash_for_address(address):
"""
Turn a human-readable address into a binary puzzle hash
Eventually this will use BECH32.
"""
return bytes.fromhex(address) |
def determine_config_values(config, hmm):
"""
Returns group of the HMM protein.
:param config: column patterns
:param hmm: HMM
:return: tuple of hmm and key
"""
for group in config:
for key in group:
if hmm in group[key]:
return (hmm, key)
return (hmm,... |
def _updater(key, value):
"""Update value of default dictionary"""
# ====>
"""
user arguments
"""
# <====
return value |
def _to_scalar(x):
"""If a list then scalar"""
try:
return x[0]
except IndexError:
return x |
def get_wetted_station(x0, x1, d0, d1, d):
"""Get the wetted length in the x-direction"""
# -- calculate the minimum and maximum depth
dmin = min(d0, d1)
dmax = max(d0, d1)
# -- if d is less than or equal to the minimum value the
# station length (xlen) is zero
if d <= dmin:
x1 =... |
def removeTags(string):
"""
Removes tags that are used on irc; ex: Marenthyu[PC] becomes Marenthyu
:param string: the untruncated string
:return: the string with everything start at an [ removed.
"""
try:
i = string.index('[')
except ValueError:
i = len(string)
... |
def centre_point(aabb):
"""Returns the centre point of the AABB.
"""
return (aabb[0] + aabb[1]) * 0.5 |
def emaAverage(y, z):
"""
@name: emaAverage
@requiredFunc ema
@description: basic ema Average function
"""
val = y * z
return val |
def compressnumbers(s):
"""Take a string that's got a lot of numbers and try to make something
that represents that number. Tries to make
unique strings from things like usb-0000:00:14.0-2
"""
n = ''
currentnum = ''
for i in s:
if i in '0123456789':
#Exclude... |
def parse_sources(sourcedef):
"""parse a source definition such as 'src1:1.0,src2' into a sequence of
tuples (src_id, weight)"""
sources = []
totalweight = 0.0
for srcdef in sourcedef.strip().split(','):
srcval = srcdef.strip().split(':')
src_id = srcval[0]
if len(srcval) > ... |
def factorial(num):
"""Returns the factorial of a nonnegative integer.
This function is provided in math module starting with Python 2.6,
but implement anyway for compatibility with older systems.
Parameters
----------
num: int
The number to factorialize.
Returns
---... |
def isToolInstalled(name):
"""Check whether `name` is on PATH."""
from distutils.spawn import find_executable
return find_executable(name) is not None |
def _tc_normalisation_weight(K, n):
""" Compute the normalisation weight for the trustworthiness and continuity
measures.
:param K: size of the neighbourhood.
:param n: total size of matrix.
"""
if K < (n/2):
return n*K*(2*n - 3*K - 1)
elif K >= (n/2):
return n*(n - K)*(n - ... |
def linsearch(l, x):
"""
Linear search for an elememnt in an array.
Linsearch(l,x)-->l is the list and x is the item to be serached.
"""
for i in range(len(l)):
if x == l[i]:
return i
else:
return False |
def flatten_parameters(parameters):
"""This takes a hierarchy of parameters as obtained from the SSM parameter store,
and flattens it in simple key/value pairs {"AccountID1": "ProjectName1", ...}
Args:
parameters (dict): the parameters obtained from the SSM
Returns:
[dict]: a flat dict... |
def get_duration_in_time( duration ):
"""
Calculate the duration in hh::mm::ss and return it
@param duration: timestamp from the system
@return: formatted string with readable hours, minutes and seconds
"""
seconds = int( duration % 60 )
minutes = int( (duratio... |
def instantantiate_map(obstacles):
""" Takes the positions of the obstacles and returns a new map. A
free position is denoted with a 0, an obstacle is denoted with 1
"""
new_map = []
for i in range(0, 100):
if i in obstacles:
new_map.append(1)
else:
new_map.ap... |
def x_timestamp_from_epoch_ns(epoch_ns):
"""
Convert a ProxyFS-style Unix timestamp to a Swift X-Timestamp header.
ProxyFS uses an integral number of nanoseconds since the epoch, while
Swift uses a floating-point number with centimillisecond (10^-5 second)
precision.
:param epoch_ns: Unix time... |
def __dobjUrl__(dobj):
"""
transform the provided digital object to a consistent format
the user may provide the full url or only the pid.
this function will return the full url in form:
'<https://meta.icos-cp.eu/objects/'+ dobj + '>'
"""
try:
dobj = str(dobj)... |
def fib(n):
"""fib calculates n-th member
of Fibonacci sequence"""
a, b = 1, 0
if n == 0:
return 0
elif n == 1:
return 1
else:
for i in range(1, n):
a, b = b + a, a
return a |
def up(spiral: list, coordinates: dict) -> bool:
"""
Move spiral up
:param coordinates: starting point
:param spiral: NxN spiral 2D array
:return: None
"""
done = True
while coordinates['row'] >= 0:
row = coordinates['row']
col = coordinates['col']
if row - 2 >= 0 and spiral[row ... |
def fib_recursive(n):
"""[summary]
Computes the n-th fibonacci number recursive.
Problem: This implementation is very slow.
approximate O(2^n)
Arguments:
n {[int]} -- [description]
Returns:
[int] -- [description]
"""
# precondition
assert n >= 0, 'n must be a p... |
def fixed_cgi_decode(s):
"""Decode the CGI-encoded string `s`:
* replace "+" by " "
* replace "%xx" by the character with hex number xx.
Return the decoded string. Raise `ValueError` for invalid inputs."""
# Mapping of hex digits to their integer values
hex_values = {
'0': 0, ... |
def attr_fmt_vars(*attrses, **kwargs):
"""Return a dict based attrs that is suitable for use in parse_fmt()."""
fmt_vars = {}
for attrs in attrses:
if type(attrs).__name__ in ['MessageMap', 'MessageMapContainer']:
for (name, attr) in attrs.iteritems():
if attr.WhichOneof... |
def is_number(s):
"""
Checks whether s is a number or not.
Args:
s (object): the object to check whether is a number or not.
Returns:
bool: Either True (s is a number) or False (s is not a number).
"""
try:
float(s)
return True
except ValueError:
ret... |
def leap_year(year):
"""leap_year returns True if *year* is a leap year and False otherwise.
Note that leap years famously fall on all years that divide by 4
except those that divide by 100 but including those that divide
by 400."""
if year % 4: # doesn't divide by 4
return False... |
def makeHtmlText(str_in):
"""add formatting for an html textarea to a string
"""
str_in = '<textarea rows="2" cols="100" style="border:double 2px blue;">' + str_in + '</textarea>'
return str_in |
def get_priority(cls):
"""
Returns the priority of a plugin.
:param cls: class to get priority from
:type cls: class
:return: the priority of cls
:rtype: int
"""
if not hasattr(cls, "_plugin_priority"):
return 0
return cls._plugin_priority |
def updateCoinsInMachine(inserted_coin, coins_in_machine_dict):
""" updateCoinsInMachine(coin, coin_in_machine_dict) ---> Boolean """
try:
inserted_coin = inserted_coin.lower()
coins_in_machine_dict[inserted_coin] += 1
except (KeyError, TypeError, ValueError):
print("Error: a '{}' ... |
def spacify(string):
"""Add 2 spaces to the beginning of each line in a multi-line string."""
return " " + " ".join(string.splitlines(True)) |
def segments_in_bbox(bbox, v_segments, h_segments):
"""Returns all line segments present inside a bounding box.
Parameters
----------
bbox : tuple
Tuple (x1, y1, x2, y2) representing a bounding box where
(x1, y1) -> lb and (x2, y2) -> rt in PDFMiner coordinate
space.
v_segme... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.