_id
stringlengths 2
7
| title
stringlengths 1
88
| partition
stringclasses 3
values | text
stringlengths 31
13.1k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q275000
|
S3Pipeline._make_fileobj
|
test
|
def _make_fileobj(self):
"""
Build file object from items.
"""
bio = BytesIO()
f = gzip.GzipFile(mode='wb', fileobj=bio) if self.use_gzip else bio
# Build file object using ItemExporter
exporter = JsonLinesItemExporter(f)
exporter.start_exporting()
for item in self.items:
|
python
|
{
"resource": ""
}
|
q275001
|
Client.get_account_state
|
test
|
def get_account_state(self, address, **kwargs):
""" Returns the account state information associated with a specific address.
:param address: a 34-bit length address (eg. AJBENSwajTzQtwyJFkiJSv7MAaaMc7DsRz)
:type address: str
|
python
|
{
"resource": ""
}
|
q275002
|
Client.get_asset_state
|
test
|
def get_asset_state(self, asset_id, **kwargs):
""" Returns the asset information associated with a specific asset ID.
:param asset_id:
an asset identifier (the transaction ID of the RegistTransaction when the asset is
registered)
:type asset_id: str
|
python
|
{
"resource": ""
}
|
q275003
|
Client.get_block
|
test
|
def get_block(self, block_hash, verbose=True, **kwargs):
""" Returns the block information associated with a specific hash value or block index.
:param block_hash: a block hash value or a block index (block height)
:param verbose:
a boolean indicating whether the detailed block information should be returned in JSON
format (otherwise the block information is returned as an hexadecimal string by the
JSON-RPC endpoint)
:type block_hash: str or int
:type verbose: bool
|
python
|
{
"resource": ""
}
|
q275004
|
Client.get_block_hash
|
test
|
def get_block_hash(self, block_index, **kwargs):
""" Returns the hash value associated with a specific block index.
:param block_index: a block index (block height)
|
python
|
{
"resource": ""
}
|
q275005
|
Client.get_block_sys_fee
|
test
|
def get_block_sys_fee(self, block_index, **kwargs):
""" Returns the system fees associated with a specific block index.
:param block_index: a block index (block
|
python
|
{
"resource": ""
}
|
q275006
|
Client.get_contract_state
|
test
|
def get_contract_state(self, script_hash, **kwargs):
""" Returns the contract information associated with a specific script hash.
:param script_hash: contract script
|
python
|
{
"resource": ""
}
|
q275007
|
Client.get_raw_transaction
|
test
|
def get_raw_transaction(self, tx_hash, verbose=True, **kwargs):
""" Returns detailed information associated with a specific transaction hash.
:param tx_hash: transaction hash
:param verbose:
a boolean indicating whether the detailed transaction information should be returned in
JSON format (otherwise the transaction information is returned as an hexadecimal string
by the JSON-RPC endpoint)
:type tx_hash: str
:type verbose: bool
:return:
dictionary containing
|
python
|
{
"resource": ""
}
|
q275008
|
Client.get_storage
|
test
|
def get_storage(self, script_hash, key, **kwargs):
""" Returns the value stored in the storage of a contract script hash for a given key.
:param script_hash: contract script hash
:param key: key to look up in the storage
:type script_hash: str
:type key: str
:return: value associated with the storage key
:rtype: bytearray
"""
hexkey =
|
python
|
{
"resource": ""
}
|
q275009
|
Client.get_tx_out
|
test
|
def get_tx_out(self, tx_hash, index, **kwargs):
""" Returns the transaction output information corresponding to a hash and index.
:param tx_hash: transaction hash
:param index:
index of the transaction output to be obtained in the transaction (starts from 0)
:type tx_hash: str
:type index: int
|
python
|
{
"resource": ""
}
|
q275010
|
Client.invoke
|
test
|
def invoke(self, script_hash, params, **kwargs):
""" Invokes a contract with given parameters and returns the result.
It should be noted that the name of the function invoked in the contract should be part of
paramaters.
:param script_hash: contract script hash
:param params: list of paramaters to be passed in to the smart contract
:type script_hash: str
:type params: list
:return: result of the invocation
:rtype: dictionary
|
python
|
{
"resource": ""
}
|
q275011
|
Client.invoke_function
|
test
|
def invoke_function(self, script_hash, operation, params, **kwargs):
""" Invokes a contract's function with given parameters and returns the result.
:param script_hash: contract script hash
:param operation: name of the operation to invoke
:param params: list of paramaters to be passed in to the smart contract
:type script_hash: str
:type operation: str
:type params: list
:return: result of the invocation
:rtype: dictionary
"""
|
python
|
{
"resource": ""
}
|
q275012
|
Client.invoke_script
|
test
|
def invoke_script(self, script, **kwargs):
""" Invokes a script on the VM and returns the result.
:param script: script runnable by the VM
:type script: str
:return: result of the invocation
:rtype: dictionary
|
python
|
{
"resource": ""
}
|
q275013
|
Client.send_raw_transaction
|
test
|
def send_raw_transaction(self, hextx, **kwargs):
""" Broadcasts a transaction over the NEO network and returns the result.
:param hextx: hexadecimal string that has been serialized
:type hextx: str
:return: result of the transaction
|
python
|
{
"resource": ""
}
|
q275014
|
Client.validate_address
|
test
|
def validate_address(self, addr, **kwargs):
""" Validates if the considered string is a valid NEO address.
:param hex: string containing a potential NEO address
|
python
|
{
"resource": ""
}
|
q275015
|
Client._call
|
test
|
def _call(self, method, params=None, request_id=None):
""" Calls the JSON-RPC endpoint. """
params = params or []
# Determines which 'id' value to use and increment the counter associated with the current
# client instance if applicable.
rid = request_id or self._id_counter
if request_id is None:
self._id_counter += 1
# Prepares the payload and the headers that will be used to forge the request.
payload = {'jsonrpc': '2.0', 'method': method, 'params': params, 'id': rid}
headers = {'Content-Type': 'application/json'}
scheme = 'https' if self.tls else 'http'
url = '{}://{}:{}'.format(scheme, self.host, self.port)
# Calls the JSON-RPC endpoint!
try:
response = self.session.post(url, headers=headers, data=json.dumps(payload))
response.raise_for_status()
except HTTPError:
raise TransportError(
'Got unsuccessful response from server (status code: {})'.format(
response.status_code),
response=response)
# Ensures the response body can be deserialized to JSON.
try:
response_data = response.json()
|
python
|
{
"resource": ""
}
|
q275016
|
is_hash256
|
test
|
def is_hash256(s):
""" Returns True if the considered string is a valid SHA256 hash. """
if not s or not isinstance(s, str):
|
python
|
{
"resource": ""
}
|
q275017
|
is_hash160
|
test
|
def is_hash160(s):
""" Returns True if the considered string is a valid RIPEMD160 hash. """
if not s or not isinstance(s, str):
return False
if not len(s) == 40:
return False
for c in s:
|
python
|
{
"resource": ""
}
|
q275018
|
encode_invocation_params
|
test
|
def encode_invocation_params(params):
""" Returns a list of paramaters meant to be passed to JSON-RPC endpoints. """
final_params = []
for p in params:
if isinstance(p, bool):
final_params.append({'type': ContractParameterTypes.BOOLEAN.value, 'value': p})
elif isinstance(p, int):
final_params.append({'type': ContractParameterTypes.INTEGER.value, 'value': p})
elif is_hash256(p):
|
python
|
{
"resource": ""
}
|
q275019
|
decode_invocation_result
|
test
|
def decode_invocation_result(result):
""" Tries to decode the values embedded in an invocation result dictionary. """
if 'stack' not in result:
return
|
python
|
{
"resource": ""
}
|
q275020
|
first_kwonly_arg
|
test
|
def first_kwonly_arg(name):
""" Emulates keyword-only arguments under python2. Works with both python2 and python3.
With this decorator you can convert all or some of the default arguments of your function
into kwonly arguments. Use ``KWONLY_REQUIRED`` as the default value of required kwonly args.
:param name: The name of the first default argument to be treated as a keyword-only argument. This default
argument along with all default arguments that follow this one will be treated as keyword only arguments.
You can also pass here the ``FIRST_DEFAULT_ARG`` constant in order to select the first default argument. This
way you turn all default arguments into keyword-only arguments. As a shortcut you can use the
``@kwonly_defaults`` decorator (without any parameters) instead of ``@first_kwonly_arg(FIRST_DEFAULT_ARG)``.
>>> from kwonly_args import first_kwonly_arg, KWONLY_REQUIRED, FIRST_DEFAULT_ARG, kwonly_defaults
>>>
>>> # this decoration converts the ``d1`` and ``d2`` default args into kwonly args
>>> @first_kwonly_arg('d1')
>>> def func(a0, a1, d0='d0', d1='d1', d2='d2', *args, **kwargs):
>>> print(a0, a1, d0, d1, d2, args, kwargs)
>>>
>>> func(0, 1, 2, 3, 4)
0 1 2 d1 d2 (3, 4) {}
>>>
>>> func(0, 1, 2, 3, 4, d2='my_param')
0 1 2 d1 my_param (3, 4) {}
>>>
>>> # d0 is an optional deyword argument, d1 is required
>>> def func(d0='d0', d1=KWONLY_REQUIRED):
>>> print(d0, d1)
>>>
>>> # The ``FIRST_DEFAULT_ARG`` constant automatically selects the first default argument so it
>>> # turns all default arguments into keyword-only ones. Both d0 and d1 are keyword-only arguments.
>>> @first_kwonly_arg(FIRST_DEFAULT_ARG)
>>> def func(a0, a1, d0='d0', d1='d1'):
>>> print(a0, a1, d0, d1)
>>>
>>> # ``@kwonly_defaults`` is a shortcut for the ``@first_kwonly_arg(FIRST_DEFAULT_ARG)``
>>> # in the previous example. This example has the same effect as the previous one.
>>> @kwonly_defaults
>>> def func(a0, a1, d0='d0', d1='d1'):
>>> print(a0, a1, d0, d1)
"""
def decorate(wrapped):
if sys.version_info[0] == 2:
arg_names, varargs, _, defaults = inspect.getargspec(wrapped)
else:
arg_names, varargs, _, defaults = inspect.getfullargspec(wrapped)[:4]
if not defaults:
raise TypeError("You can't use @first_kwonly_arg on a function that doesn't have default arguments!")
first_default_index = len(arg_names) - len(defaults)
if name is FIRST_DEFAULT_ARG:
first_kwonly_index = first_default_index
else:
try:
|
python
|
{
"resource": ""
}
|
q275021
|
snap_tz
|
test
|
def snap_tz(dttm, instruction, timezone):
"""This function handles timezone aware datetimes.
Sometimes it is necessary to keep daylight saving time switches in mind.
Args:
instruction (string): a string that encodes 0 to n transformations of a time, i.e. "-1h@h", "@mon+2d+4h", ...
dttm (datetime): a datetime with timezone
timezone: a pytz timezone
Returns:
datetime: The datetime resulting from applying all transformations to the input datetime.
Example:
>>> import pytz
>>> CET = pytz.timezone("Europe/Berlin")
>>> dttm = CET.localize(datetime(2017, 3, 26, 3, 44)
>>> dttm
datetime.datetime(2017, 3, 26,
|
python
|
{
"resource": ""
}
|
q275022
|
SnapTransformation.apply_to_with_tz
|
test
|
def apply_to_with_tz(self, dttm, timezone):
"""We make sure that after truncating we use the correct timezone,
even if we 'jump' over a daylight saving time switch.
I.e. if we apply "@d" to `Sun Oct 30 04:30:00 CET 2016` (1477798200)
|
python
|
{
"resource": ""
}
|
q275023
|
Barcode.save
|
test
|
def save(self, filename, options=None):
"""Renders the barcode and saves it in `filename`.
:parameters:
filename : String
Filename to save the barcode in (without filename
|
python
|
{
"resource": ""
}
|
q275024
|
Barcode.render
|
test
|
def render(self, writer_options=None):
"""Renders the barcode using `self.writer`.
:parameters:
writer_options : Dict
Options for `self.writer`, see writer docs for details.
:returns: Output of the writers render method.
"""
options = Barcode.default_writer_options.copy()
options.update(writer_options or {})
|
python
|
{
"resource": ""
}
|
q275025
|
EuropeanArticleNumber13.calculate_checksum
|
test
|
def calculate_checksum(self):
"""Calculates the checksum for EAN13-Code.
:returns: The checksum for `self.ean`.
:rtype: Integer
"""
def sum_(x, y):
return int(x) + int(y)
|
python
|
{
"resource": ""
}
|
q275026
|
BaseWriter.render
|
test
|
def render(self, code):
"""Renders the barcode to whatever the inheriting writer provides,
using the registered callbacks.
:parameters:
code : List
List of strings matching the writer spec
(only contain 0 or 1).
"""
if self._callbacks['initialize'] is not None:
self._callbacks['initialize'](code)
ypos = 1.0
for line in code:
# Left quiet zone is x startposition
xpos = self.quiet_zone
for mod in line:
if mod == '0':
color = self.background
else:
color = self.foreground
self._callbacks['paint_module'](xpos, ypos, self.module_width,
color)
|
python
|
{
"resource": ""
}
|
q275027
|
PerlSession.connect
|
test
|
def connect(cls, settings):
""" Call that method in the pyramid configuration phase.
"""
server = serializer('json').loads(settings['kvs.perlsess'])
server.setdefault('key_prefix', 'perlsess::')
|
python
|
{
"resource": ""
}
|
q275028
|
main
|
test
|
def main(ctx, edit, create):
"""
Simple command line tool to help manage environment variables stored in a S3-like system. Facilitates editing text
files remotely stored, as well as downloading and uploading files.
"""
# configs this module logger to behave properly
# logger messages will go to stderr (check __init__.py/patch.py)
# client output should be generated with click.echo() to go to stdout
try:
click_log.basic_config('s3conf')
logger.debug('Running main entrypoint')
if edit:
if ctx.invoked_subcommand is None:
logger.debug('Using config file %s', config.LOCAL_CONFIG_FILE)
|
python
|
{
"resource": ""
}
|
q275029
|
download
|
test
|
def download(remote_path, local_path):
"""
Download a file or folder from the S3-like service.
If REMOTE_PATH has a trailing slash it is considered to be a folder, e.g.: "s3://my-bucket/my-folder/". In this
case, LOCAL_PATH must be a folder as well. The files and subfolder structure in REMOTE_PATH are copied to
LOCAL_PATH.
If REMOTE_PATH does not have a trailing slash, it is
|
python
|
{
"resource": ""
}
|
q275030
|
upload
|
test
|
def upload(remote_path, local_path):
"""
Upload a file or folder to the S3-like service.
If LOCAL_PATH is a folder, the files and subfolder structure in LOCAL_PATH are copied to REMOTE_PATH.
If LOCAL_PATH is a file, the REMOTE_PATH file
|
python
|
{
"resource": ""
}
|
q275031
|
downsync
|
test
|
def downsync(section, map_files):
"""
For each section defined in the local config file, creates a folder inside the local config folder
named after the section. Downloads the environemnt file defined by the S3CONF variable for this section
to this folder.
"""
try:
settings = config.Settings(section=section)
storage = STORAGES['s3'](settings=settings)
conf
|
python
|
{
"resource": ""
}
|
q275032
|
diff
|
test
|
def diff(section):
"""
For each section defined in the local config file, look up for a folder inside the local config folder
named after the section. Uploads the environemnt file named as in the S3CONF variable for this section
to the remote S3CONF path.
"""
try:
settings = config.Settings(section=section)
storage = STORAGES['s3'](settings=settings)
|
python
|
{
"resource": ""
}
|
q275033
|
parse_env_var
|
test
|
def parse_env_var(value):
"""
Split a env var text like
ENV_VAR_NAME=env_var_value
into a tuple ('ENV_VAR_NAME', 'env_var_value')
"""
k, _, v = value.partition('=')
# Remove any leading and trailing spaces in key, value
|
python
|
{
"resource": ""
}
|
q275034
|
basic
|
test
|
def basic(username, password):
"""Add basic authentication to the requests of the clients."""
none()
|
python
|
{
"resource": ""
}
|
q275035
|
api_key
|
test
|
def api_key(api_key):
"""Authenticate via an api key."""
none()
_config.api_key_prefix["Authorization"] = "api-key"
|
python
|
{
"resource": ""
}
|
q275036
|
_get_json_content_from_folder
|
test
|
def _get_json_content_from_folder(folder):
"""yield objects from json files in the folder and subfolders."""
for dirpath, dirnames, filenames in os.walk(folder):
for filename in filenames:
if filename.lower().endswith(".json"):
|
python
|
{
"resource": ""
}
|
q275037
|
get_schemas
|
test
|
def get_schemas():
"""Return a dict of schema names mapping to a Schema.
The schema is of type schul_cloud_resources_api_v1.schema.Schema
"""
schemas = {}
for name
|
python
|
{
"resource": ""
}
|
q275038
|
Schema.get_schema
|
test
|
def get_schema(self):
"""Return the schema."""
path = os.path.join(self._get_schema_folder(), self._name + ".json")
with open(path, "rb") as file:
|
python
|
{
"resource": ""
}
|
q275039
|
Schema.get_resolver
|
test
|
def get_resolver(self):
"""Return a jsonschema.RefResolver for the schemas.
All schemas returned be get_schemas() are resolved locally.
"""
store = {}
for schema in get_schemas().values():
|
python
|
{
"resource": ""
}
|
q275040
|
Schema.validate
|
test
|
def validate(self, object):
"""Validate an object against the schema.
This function just passes if the schema matches the object.
If the object does not match the schema, a ValidationException is raised.
|
python
|
{
"resource": ""
}
|
q275041
|
Schema.get_valid_examples
|
test
|
def get_valid_examples(self):
"""Return a list of valid examples for the given schema."""
path
|
python
|
{
"resource": ""
}
|
q275042
|
Schema.get_invalid_examples
|
test
|
def get_invalid_examples(self):
"""Return a list of examples which violate the schema."""
path
|
python
|
{
"resource": ""
}
|
q275043
|
OneDriveAuth.auth_user_get_url
|
test
|
def auth_user_get_url(self, scope=None):
'Build authorization URL for User Agent.'
if not self.client_id: raise AuthMissingError('No client_id specified')
return '{}?{}'.format(self.auth_url_user, urllib.urlencode(dict(
|
python
|
{
"resource": ""
}
|
q275044
|
OneDriveAuth.auth_user_process_url
|
test
|
def auth_user_process_url(self, url):
'Process tokens and errors from redirect_uri.'
url = urlparse.urlparse(url)
url_qs = dict(it.chain.from_iterable(
urlparse.parse_qsl(v) for v in [url.query, url.fragment] ))
if url_qs.get('error'):
raise APIAuthError(
|
python
|
{
"resource": ""
}
|
q275045
|
OneDriveAuth.auth_get_token
|
test
|
def auth_get_token(self, check_scope=True):
'Refresh or acquire access_token.'
res = self.auth_access_data_raw =
|
python
|
{
"resource": ""
}
|
q275046
|
OneDriveAPIWrapper.get_user_id
|
test
|
def get_user_id(self):
'Returns "id" of a OneDrive user.'
if
|
python
|
{
"resource": ""
}
|
q275047
|
OneDriveAPIWrapper.listdir
|
test
|
def listdir(self, folder_id='me/skydrive', limit=None, offset=None):
'Get OneDrive object representing list of objects in a folder.'
|
python
|
{
"resource": ""
}
|
q275048
|
OneDriveAPIWrapper.mkdir
|
test
|
def mkdir(self, name=None, folder_id='me/skydrive', metadata=dict()):
'''Create a folder with a specified "name" attribute.
folder_id allows to specify a parent folder.
metadata mapping may contain additional folder properties to pass to an API.'''
|
python
|
{
"resource": ""
}
|
q275049
|
OneDriveAPIWrapper.comment_add
|
test
|
def comment_add(self, obj_id, message):
'Add comment message to a specified object.'
return self( self._api_url_join(obj_id, 'comments'),
|
python
|
{
"resource": ""
}
|
q275050
|
decode_obj
|
test
|
def decode_obj(obj, force=False):
'Convert or dump object to unicode.'
if isinstance(obj, unicode): return obj
elif isinstance(obj, bytes):
if force_encoding is not None: return obj.decode(force_encoding)
if chardet:
enc_guess = chardet.detect(obj)
if enc_guess['confidence']
|
python
|
{
"resource": ""
}
|
q275051
|
set_drop_target
|
test
|
def set_drop_target(obj, root, designer, inspector):
"Recursively create and set the drop target for obj and childs"
if obj._meta.container:
dt = ToolBoxDropTarget(obj, root, designer=designer,
|
python
|
{
"resource": ""
}
|
q275052
|
ToolBox.start_drag_opperation
|
test
|
def start_drag_opperation(self, evt):
"Event handler for drag&drop functionality"
# get the control
ctrl = self.menu_ctrl_map[evt.GetToolId()]
# create our own data format and use it in a custom data object
ldata = wx.CustomDataObject("gui")
ldata.SetData(ctrl._meta.name) # only strings are allowed!
# Also create a Bitmap version of the drawing
bmp = ctrl._image.GetBitmap()
# Now make a data object for the bitmap and also a composite
# data object holding both of the others.
bdata = wx.BitmapDataObject(bmp)
data = wx.DataObjectComposite()
data.Add(ldata)
|
python
|
{
"resource": ""
}
|
q275053
|
ToolBox.set_default_tlw
|
test
|
def set_default_tlw(self, tlw, designer, inspector):
"track default top level
|
python
|
{
"resource": ""
}
|
q275054
|
inspect
|
test
|
def inspect(obj):
"Open the inspector windows for a given object"
from gui.tools.inspector import InspectorTool
inspector =
|
python
|
{
"resource": ""
}
|
q275055
|
shell
|
test
|
def shell():
"Open a shell"
from gui.tools.debug import Shell
|
python
|
{
"resource": ""
}
|
q275056
|
migrate_font
|
test
|
def migrate_font(font):
"Convert PythonCard font description to gui2py style"
if 'faceName' in font:
font['face'] = font.pop('faceName')
if 'family' in
|
python
|
{
"resource": ""
}
|
q275057
|
HtmlBox.load_page
|
test
|
def load_page(self, location):
"Loads HTML page from location and then displays it"
if not location:
|
python
|
{
"resource": ""
}
|
q275058
|
GetParam
|
test
|
def GetParam(tag, param, default=__SENTINEL):
""" Convenience function for accessing tag parameters"""
if tag.HasParam(param):
return tag.GetParam(param)
else:
|
python
|
{
"resource": ""
}
|
q275059
|
send
|
test
|
def send(evt):
"Process an outgoing communication"
# get the text written by the user (input textbox control)
msg = ctrl_input.value
# send the message (replace with socket/queue/etc.)
gui.alert(msg, "Message")
|
python
|
{
"resource": ""
}
|
q275060
|
wellcome_tip
|
test
|
def wellcome_tip(wx_obj):
"Show a tip message"
msg = ("Close the main window to exit & save.\n"
"Drag & Drop / Click the controls from the ToolBox to create new ones.\n"
"Left click on the created controls to select them.\n"
"Double click to edit the default property.\n"
"Right click to pop-up the context menu.\n")
# create a super tool tip manager and set some styles
stt = STT.SuperToolTip(msg)
stt.SetHeader("Welcome to gui2py designer!")
stt.SetDrawHeaderLine(True)
stt.ApplyStyle("Office 2007 Blue")
stt.SetDropShadow(True)
stt.SetHeaderBitmap(images.designer.GetBitmap())
stt.SetEndDelay(15000) # hide in 15 s
# create a independent tip window, show/hide manually (avoid binding wx_obj)
|
python
|
{
"resource": ""
}
|
q275061
|
BasicDesigner.mouse_down
|
test
|
def mouse_down(self, evt):
"Get the selected object and store start position"
if DEBUG: print "down!"
if (not evt.ControlDown() and not evt.ShiftDown()) or evt.AltDown():
for obj in self.selection:
# clear marker
if obj.sel_marker:
obj.sel_marker.show(False)
obj.sel_marker.destroy()
obj.sel_marker = None
self.selection = [] # clear previous selection
wx_obj = evt.GetEventObject()
if wx_obj.Parent is None or evt.AltDown():
if not evt.AltDown():
evt.Skip()
# start the rubberband effect (multiple selection using the mouse)
self.current = wx_obj
self.overlay = wx.Overlay()
self.pos = evt.GetPosition()
self.parent.wx_obj.CaptureMouse()
#if self.inspector and hasattr(wx_obj, "obj"):
# self.inspector.inspect(wx_obj.obj) # inspect top level window
#self.dclick = False
else:
# create the selection marker and assign it to the control
obj
|
python
|
{
"resource": ""
}
|
q275062
|
BasicDesigner.mouse_move
|
test
|
def mouse_move(self, evt):
"Move the selected object"
if DEBUG: print "move!"
if self.current and not self.overlay:
wx_obj = self.current
sx, sy = self.start
x, y = wx.GetMousePosition()
# calculate the new position (this will overwrite relative dimensions):
x, y = (x + sx, y + sy)
if evt.ShiftDown(): # snap to grid:
x = x / GRID_SIZE[0] * GRID_SIZE[0]
y = y / GRID_SIZE[1] * GRID_SIZE[1]
# calculate the diff to use in the rest of the selected objects:
ox, oy = wx_obj.obj.pos
dx, dy = (x - ox), (y - oy)
# move all selected objects:
for obj in self.selection:
x, y = obj.pos
x = x + dx
y = y + dy
obj.pos = (wx.Point(x, y))
elif self.overlay:
wx_obj = self.current
pos = evt.GetPosition()
# convert to relative client coordinates of the containter:
|
python
|
{
"resource": ""
}
|
q275063
|
BasicDesigner.do_resize
|
test
|
def do_resize(self, evt, wx_obj, (n, w, s, e)):
"Called by SelectionTag"
# calculate the pos (minus the offset, not in a panel like rw!)
pos = wx_obj.ScreenToClient(wx.GetMousePosition())
x, y = pos
if evt.ShiftDown(): # snap to grid:
x = x / GRID_SIZE[0] * GRID_SIZE[0]
y = y / GRID_SIZE[1] * GRID_SIZE[1]
pos = wx.Point(x, y)
if not self.resizing or self.resizing != (wx_obj, (n, w, s, e)):
self.pos = list(pos) # store starting point
self.resizing = (wx_obj, (n, w, s, e)) # track obj and handle
else:
delta = pos - self.pos
if DEBUG: print "RESIZING: n, w, s, e", n, w, s, e
if n or w or s or e:
# resize according the direction (n, w, s, e)
x = wx_obj.Position[0] + e * delta[0]
y = wx_obj.Position[1] + n * delta[1]
if w or e:
if not isinstance(wx_obj, wx.TopLevelWindow):
width = wx_obj.Size[0] + (w - e) * delta[0]
else:
width = wx_obj.ClientSize[0] + (w - e) * delta[0]
else:
width = None
if n or s:
height = wx_obj.Size[1] + (s - n) * delta[1]
else:
height = None
else:
# just move
x = wx_obj.Position[0] + delta[0]
y = wx_obj.Position[1] + delta[1]
width = height = None
|
python
|
{
"resource": ""
}
|
q275064
|
BasicDesigner.key_press
|
test
|
def key_press(self, event):
"support cursor keys to move components one pixel at a time"
key = event.GetKeyCode()
if key in (wx.WXK_LEFT, wx.WXK_UP, wx.WXK_RIGHT, wx.WXK_DOWN):
for obj in self.selection:
x, y = obj.pos
if event.ShiftDown(): # snap to grid:t
# for now I'm only going to align to grid
# in the direction of the cursor movement
if key == wx.WXK_LEFT:
x = (x - GRID_SIZE[0]) / GRID_SIZE[0] * GRID_SIZE[0]
elif key == wx.WXK_RIGHT:
x = (x + GRID_SIZE[0]) / GRID_SIZE[0] * GRID_SIZE[0]
elif key == wx.WXK_UP:
y = (y - GRID_SIZE[1]) / GRID_SIZE[1] * GRID_SIZE[1]
elif key == wx.WXK_DOWN:
y = (y + GRID_SIZE[1])
|
python
|
{
"resource": ""
}
|
q275065
|
BasicDesigner.delete
|
test
|
def delete(self, event):
"delete all of the selected objects"
# get the selected objects (if any)
for obj in self.selection:
if obj:
if DEBUG: print "deleting", obj.name
|
python
|
{
"resource": ""
}
|
q275066
|
BasicDesigner.duplicate
|
test
|
def duplicate(self, event):
"create a copy of each selected object"
# duplicate the selected objects (if any)
new_selection = []
for obj in self.selection:
if obj:
if DEBUG: print "duplicating", obj.name
obj.sel_marker.destroy()
obj.sel_marker = None
obj2 = obj.duplicate()
obj2.sel_marker
|
python
|
{
"resource": ""
}
|
q275067
|
Facade.refresh
|
test
|
def refresh(self):
"Capture the new control superficial image after an update"
self.bmp = self.obj.snapshot()
|
python
|
{
"resource": ""
}
|
q275068
|
CustomToolTipWindow.CalculateBestPosition
|
test
|
def CalculateBestPosition(self,widget):
"When dealing with a Top-Level window position it absolute lower-right"
if isinstance(widget, wx.Frame):
screen = wx.ClientDisplayRect()[2:]
left,top = widget.ClientToScreenXY(0,0)
right,bottom = widget.ClientToScreenXY(*widget.GetClientRect()[2:])
size = self.GetSize()
|
python
|
{
"resource": ""
}
|
q275069
|
wx_ListCtrl.GetPyData
|
test
|
def GetPyData(self, item):
"Returns the pyth item data associated with the item"
wx_data = self.GetItemData(item)
|
python
|
{
"resource": ""
}
|
q275070
|
wx_ListCtrl.SetPyData
|
test
|
def SetPyData(self, item, py_data):
"Set the python item data associated wit the wx item"
wx_data = wx.NewId() # create a suitable
|
python
|
{
"resource": ""
}
|
q275071
|
wx_ListCtrl.FindPyData
|
test
|
def FindPyData(self, start, py_data):
"Do a reverse look up for an item containing the requested data"
# first, look at our internal dict:
wx_data = self._wx_data_map[py_data]
# do the real search at the wx control:
if wx.VERSION < (3, 0, 0) or 'classic' in wx.version():
|
python
|
{
"resource": ""
}
|
q275072
|
wx_ListCtrl.DeleteItem
|
test
|
def DeleteItem(self, item):
"Remove the item from the list and unset the related data"
wx_data = self.GetItemData(item)
py_data = self._py_data_map[wx_data]
|
python
|
{
"resource": ""
}
|
q275073
|
wx_ListCtrl.DeleteAllItems
|
test
|
def DeleteAllItems(self):
"Remove all the item from the list and unset the related data"
self._py_data_map.clear()
|
python
|
{
"resource": ""
}
|
q275074
|
ListView.clear_all
|
test
|
def clear_all(self):
"Remove all items and column headings"
self.clear()
for
|
python
|
{
"resource": ""
}
|
q275075
|
ItemContainerControl._set_selection
|
test
|
def _set_selection(self, index, dummy=False):
"Sets the item at index 'n' to be the selected item."
# only change selection if index is None and not dummy:
if index is None:
self.wx_obj.SetSelection(-1)
# clean up text if control supports it:
if hasattr(self.wx_obj, "SetValue"):
self.wx_obj.SetValue("")
else:
self.wx_obj.SetSelection(index)
# send a programmatically event (not issued by wx)
wx_event = ItemContainerControlSelectEvent(self._commandtype,
|
python
|
{
"resource": ""
}
|
q275076
|
ItemContainerControl._get_string_selection
|
test
|
def _get_string_selection(self):
"Returns the label of the selected item or an empty string if none"
if self.multiselect:
return [self.wx_obj.GetString(i) for i in
|
python
|
{
"resource": ""
}
|
q275077
|
ItemContainerControl.set_data
|
test
|
def set_data(self, n, data):
"Associate the given client data with the item at position n."
self.wx_obj.SetClientData(n, data)
|
python
|
{
"resource": ""
}
|
q275078
|
ItemContainerControl.append
|
test
|
def append(self, a_string, data=None):
"Adds the item to the control, associating the given data
|
python
|
{
"resource": ""
}
|
q275079
|
represent
|
test
|
def represent(obj, prefix, parent="", indent=0, context=False, max_cols=80):
"Construct a string representing the object"
try:
name = getattr(obj, "name", "")
class_name = "%s.%s" % (prefix, obj.__class__.__name__)
padding = len(class_name) + 1 + indent * 4 + (5 if context else 0)
params = []
for (k, spec) in sorted(obj._meta.specs.items(), key=get_sort_key):
if k == "index": # index is really defined by creation order
continue # also, avoid infinite recursion
if k == "parent" and parent != "":
v = parent
else:
v = getattr(obj, k, "")
if (not isinstance(spec, InternalSpec)
and v != spec.default
and (k != 'id' or v > 0)
and isinstance(v,
(basestring, int, long, float, bool, dict, list,
decimal.Decimal,
datetime.datetime, datetime.date, datetime.time,
Font, Color))
and repr(v) != 'None'
):
v = repr(v)
|
python
|
{
"resource": ""
}
|
q275080
|
get
|
test
|
def get(obj_name, init=False):
"Find an object already created"
wx_parent = None
# check if new_parent is given as string (useful for designer!)
if isinstance(obj_name, basestring):
# find the object reference in the already created gui2py objects
# TODO: only useful for designer, get a better way
obj_parent = COMPONENTS.get(obj_name)
if not obj_parent:
# try to find window (it can be a plain wx frame/control)
wx_parent = wx.FindWindowByName(obj_name)
if wx_parent:
# store gui object
|
python
|
{
"resource": ""
}
|
q275081
|
Component.duplicate
|
test
|
def duplicate(self, new_parent=None):
"Create a new object exactly similar to self"
kwargs = {}
for spec_name, spec in self._meta.specs.items():
value = getattr(self, spec_name)
if isinstance(value, Color):
print "COLOR", value, value.default
if value.default:
value = None
if value is not None:
kwargs[spec_name] = value
del kwargs['parent']
|
python
|
{
"resource": ""
}
|
q275082
|
SizerMixin._sizer_add
|
test
|
def _sizer_add(self, child):
"called when adding a control to the window"
if self.sizer:
if DEBUG: print "adding to sizer:", child.name
border = None
if not border:
border = child.sizer_border
flags = child._sizer_flags
if child.sizer_align:
flags |= child._sizer_align
if child.sizer_expand:
flags |= wx.EXPAND
if 'grid' in self.sizer:
|
python
|
{
"resource": ""
}
|
q275083
|
ControlSuper.set_parent
|
test
|
def set_parent(self, new_parent, init=False):
"Re-parent a child control with the new wx_obj parent"
Component.set_parent(self, new_parent, init)
# if not called from constructor, we must also reparent in wx:
if not init:
|
python
|
{
"resource": ""
}
|
q275084
|
ImageBackgroundMixin.__tile_background
|
test
|
def __tile_background(self, dc):
"make several copies of the background bitmap"
sz = self.wx_obj.GetClientSize()
bmp = self._bitmap.get_bits()
w = bmp.GetWidth()
h = bmp.GetHeight()
if isinstance(self, wx.ScrolledWindow):
# adjust for scrolled position
spx, spy = self.wx_obj.GetScrollPixelsPerUnit()
vsx, vsy = self.wx_obj.GetViewStart()
dx, dy = (spx * vsx) % w, (spy * vsy) % h
else:
|
python
|
{
"resource": ""
}
|
q275085
|
ImageBackgroundMixin.__on_erase_background
|
test
|
def __on_erase_background(self, evt):
"Draw the image as background"
if self._bitmap:
dc = evt.GetDC()
if not dc:
dc = wx.ClientDC(self)
r = self.wx_obj.GetUpdateRegion().GetBox()
dc.SetClippingRegion(r.x, r.y, r.width, r.height)
|
python
|
{
"resource": ""
}
|
q275086
|
Label.__on_paint
|
test
|
def __on_paint(self, event):
"Custom draws the label when transparent background is needed"
# use a Device Context that supports anti-aliased drawing
|
python
|
{
"resource": ""
}
|
q275087
|
find_modules
|
test
|
def find_modules(rootpath, skip):
"""
Look for every file in the directory tree and return a dict
Hacked from sphinx.autodoc
"""
INITPY = '__init__.py'
rootpath = os.path.normpath(os.path.abspath(rootpath))
if INITPY in os.listdir(rootpath):
root_package = rootpath.split(os.path.sep)[-1]
print "Searching modules in", rootpath
else:
print "No modules in", rootpath
return
def makename(package, module):
"""Join package and module with a dot."""
if package:
name = package
if module:
name += '.' + module
else:
name = module
return name
skipall = []
for m in skip.keys():
if skip[m] is None: skipall.append(m)
tree = {}
saved = 0
found = 0
def save(module, submodule):
name = module+ "."+ submodule
|
python
|
{
"resource": ""
}
|
q275088
|
GridView._get_column_headings
|
test
|
def _get_column_headings(self):
"Return a list of children sub-components that are column headings"
# return it in the same order as inserted in the Grid
|
python
|
{
"resource": ""
}
|
q275089
|
GridTable.ResetView
|
test
|
def ResetView(self, grid):
"Update the grid if rows and columns have been added or deleted"
grid.BeginBatch()
for current, new, delmsg, addmsg in [
(self._rows, self.GetNumberRows(),
gridlib.GRIDTABLE_NOTIFY_ROWS_DELETED,
gridlib.GRIDTABLE_NOTIFY_ROWS_APPENDED),
(self._cols, self.GetNumberCols(),
gridlib.GRIDTABLE_NOTIFY_COLS_DELETED,
gridlib.GRIDTABLE_NOTIFY_COLS_APPENDED),
|
python
|
{
"resource": ""
}
|
q275090
|
GridTable.UpdateValues
|
test
|
def UpdateValues(self, grid):
"Update all displayed values"
# This sends an event to the grid table to update all of the values
msg = gridlib.GridTableMessage(self,
|
python
|
{
"resource": ""
}
|
q275091
|
GridTable._updateColAttrs
|
test
|
def _updateColAttrs(self, grid):
"update the column attributes to add the appropriate renderer"
col = 0
for column in self.columns:
attr = gridlib.GridCellAttr()
if False: # column.readonly
attr.SetReadOnly()
|
python
|
{
"resource": ""
}
|
q275092
|
GridTable.SortColumn
|
test
|
def SortColumn(self, col):
"col -> sort the data based on the column indexed by col"
name = self.columns[col].name
_data = []
for row in self.data:
rowname, entry = row
|
python
|
{
"resource": ""
}
|
q275093
|
GridModel.clear
|
test
|
def clear(self):
"Remove all rows and reset internal structures"
## list has no clear ... remove items in reverse order
for i in range(len(self)-1, -1, -1):
del self[i]
|
python
|
{
"resource": ""
}
|
q275094
|
ComboCellEditor.Create
|
test
|
def Create(self, parent, id, evtHandler):
"Called to create the control, which must derive from wxControl."
self._tc = wx.ComboBox(parent, id, "", (100, 50))
self.SetControl(self._tc)
|
python
|
{
"resource": ""
}
|
q275095
|
ComboCellEditor.BeginEdit
|
test
|
def BeginEdit(self, row, col, grid):
"Fetch the value from the table and prepare the edit control"
self.startValue = grid.GetTable().GetValue(row, col)
choices = grid.GetTable().columns[col]._choices
|
python
|
{
"resource": ""
}
|
q275096
|
ComboCellEditor.EndEdit
|
test
|
def EndEdit(self, row, col, grid, val=None):
"Complete the editing of the current cell. Returns True if changed"
changed = False
val = self._tc.GetStringSelection()
print "val", val, row, col, self.startValue
if val != self.startValue:
|
python
|
{
"resource": ""
}
|
q275097
|
ComboCellEditor.IsAcceptedKey
|
test
|
def IsAcceptedKey(self, evt):
"Return True to allow the given key to start editing"
## Oops, there's a bug here, we'll have to do it ourself..
##return self.base_IsAcceptedKey(evt)
|
python
|
{
"resource": ""
}
|
q275098
|
ComboCellEditor.StartingKey
|
test
|
def StartingKey(self, evt):
"This will be called to let the editor do something with the first key"
key = evt.GetKeyCode()
ch = None
if key in [wx.WXK_NUMPAD0, wx.WXK_NUMPAD1, wx.WXK_NUMPAD2, wx.WXK_NUMPAD3, wx.WXK_NUMPAD4,
wx.WXK_NUMPAD5, wx.WXK_NUMPAD6, wx.WXK_NUMPAD7, wx.WXK_NUMPAD8, wx.WXK_NUMPAD9]:
ch = ch = chr(ord('0') + key - wx.WXK_NUMPAD0)
elif key <
|
python
|
{
"resource": ""
}
|
q275099
|
TypeHandler
|
test
|
def TypeHandler(type_name):
""" A metaclass generator. Returns a metaclass which
will register it's class as the class that handles input type=typeName
"""
def metaclass(name, bases, dict):
|
python
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.