repo stringlengths 7 55 | path stringlengths 4 127 | func_name stringlengths 1 88 | original_string stringlengths 75 19.8k | language stringclasses 1 value | code stringlengths 75 19.8k | code_tokens listlengths 20 707 | docstring stringlengths 3 17.3k | docstring_tokens listlengths 3 222 | sha stringlengths 40 40 | url stringlengths 87 242 | partition stringclasses 1 value | idx int64 0 252k |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
oceanprotocol/squid-py | squid_py/aquarius/aquarius.py | Aquarius.validate_metadata | def validate_metadata(self, metadata):
"""
Validate that the metadata of your ddo is valid.
:param metadata: conforming to the Metadata accepted by Ocean Protocol, dict
:return: bool
"""
response = self.requests_session.post(
f'{self.url}/validate',
data=json.dumps(metadata),
headers=self._headers
)
if response.content == b'true\n':
return True
else:
logger.info(self._parse_search_response(response.content))
return False | python | def validate_metadata(self, metadata):
"""
Validate that the metadata of your ddo is valid.
:param metadata: conforming to the Metadata accepted by Ocean Protocol, dict
:return: bool
"""
response = self.requests_session.post(
f'{self.url}/validate',
data=json.dumps(metadata),
headers=self._headers
)
if response.content == b'true\n':
return True
else:
logger.info(self._parse_search_response(response.content))
return False | [
"def",
"validate_metadata",
"(",
"self",
",",
"metadata",
")",
":",
"response",
"=",
"self",
".",
"requests_session",
".",
"post",
"(",
"f'{self.url}/validate'",
",",
"data",
"=",
"json",
".",
"dumps",
"(",
"metadata",
")",
",",
"headers",
"=",
"self",
".",
"_headers",
")",
"if",
"response",
".",
"content",
"==",
"b'true\\n'",
":",
"return",
"True",
"else",
":",
"logger",
".",
"info",
"(",
"self",
".",
"_parse_search_response",
"(",
"response",
".",
"content",
")",
")",
"return",
"False"
] | Validate that the metadata of your ddo is valid.
:param metadata: conforming to the Metadata accepted by Ocean Protocol, dict
:return: bool | [
"Validate",
"that",
"the",
"metadata",
"of",
"your",
"ddo",
"is",
"valid",
"."
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/aquarius/aquarius.py#L248-L264 | train | 235,400 |
oceanprotocol/squid-py | squid_py/agreements/utils.py | get_sla_template_path | def get_sla_template_path(service_type=ServiceTypes.ASSET_ACCESS):
"""
Get the template for a ServiceType.
:param service_type: ServiceTypes
:return: Path of the template, str
"""
if service_type == ServiceTypes.ASSET_ACCESS:
name = 'access_sla_template.json'
elif service_type == ServiceTypes.CLOUD_COMPUTE:
name = 'compute_sla_template.json'
elif service_type == ServiceTypes.FITCHAIN_COMPUTE:
name = 'fitchain_sla_template.json'
else:
raise ValueError(f'Invalid/unsupported service agreement type {service_type}')
return os.path.join(os.path.sep, *os.path.realpath(__file__).split(os.path.sep)[1:-1], name) | python | def get_sla_template_path(service_type=ServiceTypes.ASSET_ACCESS):
"""
Get the template for a ServiceType.
:param service_type: ServiceTypes
:return: Path of the template, str
"""
if service_type == ServiceTypes.ASSET_ACCESS:
name = 'access_sla_template.json'
elif service_type == ServiceTypes.CLOUD_COMPUTE:
name = 'compute_sla_template.json'
elif service_type == ServiceTypes.FITCHAIN_COMPUTE:
name = 'fitchain_sla_template.json'
else:
raise ValueError(f'Invalid/unsupported service agreement type {service_type}')
return os.path.join(os.path.sep, *os.path.realpath(__file__).split(os.path.sep)[1:-1], name) | [
"def",
"get_sla_template_path",
"(",
"service_type",
"=",
"ServiceTypes",
".",
"ASSET_ACCESS",
")",
":",
"if",
"service_type",
"==",
"ServiceTypes",
".",
"ASSET_ACCESS",
":",
"name",
"=",
"'access_sla_template.json'",
"elif",
"service_type",
"==",
"ServiceTypes",
".",
"CLOUD_COMPUTE",
":",
"name",
"=",
"'compute_sla_template.json'",
"elif",
"service_type",
"==",
"ServiceTypes",
".",
"FITCHAIN_COMPUTE",
":",
"name",
"=",
"'fitchain_sla_template.json'",
"else",
":",
"raise",
"ValueError",
"(",
"f'Invalid/unsupported service agreement type {service_type}'",
")",
"return",
"os",
".",
"path",
".",
"join",
"(",
"os",
".",
"path",
".",
"sep",
",",
"*",
"os",
".",
"path",
".",
"realpath",
"(",
"__file__",
")",
".",
"split",
"(",
"os",
".",
"path",
".",
"sep",
")",
"[",
"1",
":",
"-",
"1",
"]",
",",
"name",
")"
] | Get the template for a ServiceType.
:param service_type: ServiceTypes
:return: Path of the template, str | [
"Get",
"the",
"template",
"for",
"a",
"ServiceType",
"."
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/agreements/utils.py#L11-L27 | train | 235,401 |
oceanprotocol/squid-py | squid_py/ocean/ocean_accounts.py | OceanAccounts.balance | def balance(self, account):
"""
Return the balance, a tuple with the eth and ocn balance.
:param account: Account instance to return the balance of
:return: Balance tuple of (eth, ocn)
"""
return Balance(self._keeper.get_ether_balance(account.address),
self._keeper.token.get_token_balance(account.address)) | python | def balance(self, account):
"""
Return the balance, a tuple with the eth and ocn balance.
:param account: Account instance to return the balance of
:return: Balance tuple of (eth, ocn)
"""
return Balance(self._keeper.get_ether_balance(account.address),
self._keeper.token.get_token_balance(account.address)) | [
"def",
"balance",
"(",
"self",
",",
"account",
")",
":",
"return",
"Balance",
"(",
"self",
".",
"_keeper",
".",
"get_ether_balance",
"(",
"account",
".",
"address",
")",
",",
"self",
".",
"_keeper",
".",
"token",
".",
"get_token_balance",
"(",
"account",
".",
"address",
")",
")"
] | Return the balance, a tuple with the eth and ocn balance.
:param account: Account instance to return the balance of
:return: Balance tuple of (eth, ocn) | [
"Return",
"the",
"balance",
"a",
"tuple",
"with",
"the",
"eth",
"and",
"ocn",
"balance",
"."
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/ocean/ocean_accounts.py#L44-L52 | train | 235,402 |
oceanprotocol/squid-py | squid_py/agreements/register_service_agreement.py | process_agreement_events_consumer | def process_agreement_events_consumer(publisher_address, agreement_id, did, service_agreement,
price, consumer_account, condition_ids,
consume_callback):
"""
Process the agreement events during the register of the service agreement for the consumer side.
:param publisher_address: ethereum account address of publisher, hex str
:param agreement_id: id of the agreement, hex str
:param did: DID, str
:param service_agreement: ServiceAgreement instance
:param price: Asset price, int
:param consumer_account: Account instance of the consumer
:param condition_ids: is a list of bytes32 content-addressed Condition IDs, bytes32
:param consume_callback:
:return:
"""
conditions_dict = service_agreement.condition_by_name
events_manager = EventsManager.get_instance(Keeper.get_instance())
events_manager.watch_agreement_created_event(
agreement_id,
lock_reward_condition.fulfillLockRewardCondition,
None,
(agreement_id, price, consumer_account),
EVENT_WAIT_TIMEOUT,
)
if consume_callback:
def _refund_callback(_price, _publisher_address, _condition_ids):
def do_refund(_event, _agreement_id, _did, _service_agreement, _consumer_account, *_):
escrow_reward_condition.refund_reward(
_event, _agreement_id, _did, _service_agreement, _price,
_consumer_account, _publisher_address, _condition_ids
)
return do_refund
events_manager.watch_access_event(
agreement_id,
escrow_reward_condition.consume_asset,
_refund_callback(price, publisher_address, condition_ids),
(agreement_id, did, service_agreement, consumer_account, consume_callback),
conditions_dict['accessSecretStore'].timeout
) | python | def process_agreement_events_consumer(publisher_address, agreement_id, did, service_agreement,
price, consumer_account, condition_ids,
consume_callback):
"""
Process the agreement events during the register of the service agreement for the consumer side.
:param publisher_address: ethereum account address of publisher, hex str
:param agreement_id: id of the agreement, hex str
:param did: DID, str
:param service_agreement: ServiceAgreement instance
:param price: Asset price, int
:param consumer_account: Account instance of the consumer
:param condition_ids: is a list of bytes32 content-addressed Condition IDs, bytes32
:param consume_callback:
:return:
"""
conditions_dict = service_agreement.condition_by_name
events_manager = EventsManager.get_instance(Keeper.get_instance())
events_manager.watch_agreement_created_event(
agreement_id,
lock_reward_condition.fulfillLockRewardCondition,
None,
(agreement_id, price, consumer_account),
EVENT_WAIT_TIMEOUT,
)
if consume_callback:
def _refund_callback(_price, _publisher_address, _condition_ids):
def do_refund(_event, _agreement_id, _did, _service_agreement, _consumer_account, *_):
escrow_reward_condition.refund_reward(
_event, _agreement_id, _did, _service_agreement, _price,
_consumer_account, _publisher_address, _condition_ids
)
return do_refund
events_manager.watch_access_event(
agreement_id,
escrow_reward_condition.consume_asset,
_refund_callback(price, publisher_address, condition_ids),
(agreement_id, did, service_agreement, consumer_account, consume_callback),
conditions_dict['accessSecretStore'].timeout
) | [
"def",
"process_agreement_events_consumer",
"(",
"publisher_address",
",",
"agreement_id",
",",
"did",
",",
"service_agreement",
",",
"price",
",",
"consumer_account",
",",
"condition_ids",
",",
"consume_callback",
")",
":",
"conditions_dict",
"=",
"service_agreement",
".",
"condition_by_name",
"events_manager",
"=",
"EventsManager",
".",
"get_instance",
"(",
"Keeper",
".",
"get_instance",
"(",
")",
")",
"events_manager",
".",
"watch_agreement_created_event",
"(",
"agreement_id",
",",
"lock_reward_condition",
".",
"fulfillLockRewardCondition",
",",
"None",
",",
"(",
"agreement_id",
",",
"price",
",",
"consumer_account",
")",
",",
"EVENT_WAIT_TIMEOUT",
",",
")",
"if",
"consume_callback",
":",
"def",
"_refund_callback",
"(",
"_price",
",",
"_publisher_address",
",",
"_condition_ids",
")",
":",
"def",
"do_refund",
"(",
"_event",
",",
"_agreement_id",
",",
"_did",
",",
"_service_agreement",
",",
"_consumer_account",
",",
"*",
"_",
")",
":",
"escrow_reward_condition",
".",
"refund_reward",
"(",
"_event",
",",
"_agreement_id",
",",
"_did",
",",
"_service_agreement",
",",
"_price",
",",
"_consumer_account",
",",
"_publisher_address",
",",
"_condition_ids",
")",
"return",
"do_refund",
"events_manager",
".",
"watch_access_event",
"(",
"agreement_id",
",",
"escrow_reward_condition",
".",
"consume_asset",
",",
"_refund_callback",
"(",
"price",
",",
"publisher_address",
",",
"condition_ids",
")",
",",
"(",
"agreement_id",
",",
"did",
",",
"service_agreement",
",",
"consumer_account",
",",
"consume_callback",
")",
",",
"conditions_dict",
"[",
"'accessSecretStore'",
"]",
".",
"timeout",
")"
] | Process the agreement events during the register of the service agreement for the consumer side.
:param publisher_address: ethereum account address of publisher, hex str
:param agreement_id: id of the agreement, hex str
:param did: DID, str
:param service_agreement: ServiceAgreement instance
:param price: Asset price, int
:param consumer_account: Account instance of the consumer
:param condition_ids: is a list of bytes32 content-addressed Condition IDs, bytes32
:param consume_callback:
:return: | [
"Process",
"the",
"agreement",
"events",
"during",
"the",
"register",
"of",
"the",
"service",
"agreement",
"for",
"the",
"consumer",
"side",
"."
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/agreements/register_service_agreement.py#L54-L96 | train | 235,403 |
oceanprotocol/squid-py | squid_py/agreements/register_service_agreement.py | process_agreement_events_publisher | def process_agreement_events_publisher(publisher_account, agreement_id, did, service_agreement,
price, consumer_address, condition_ids):
"""
Process the agreement events during the register of the service agreement for the publisher side
:param publisher_account: Account instance of the publisher
:param agreement_id: id of the agreement, hex str
:param did: DID, str
:param service_agreement: ServiceAgreement instance
:param price: Asset price, int
:param consumer_address: ethereum account address of consumer, hex str
:param condition_ids: is a list of bytes32 content-addressed Condition IDs, bytes32
:return:
"""
conditions_dict = service_agreement.condition_by_name
events_manager = EventsManager.get_instance(Keeper.get_instance())
events_manager.watch_lock_reward_event(
agreement_id,
access_secret_store_condition.fulfillAccessSecretStoreCondition,
None,
(agreement_id, did, service_agreement,
consumer_address, publisher_account),
conditions_dict['lockReward'].timeout
)
events_manager.watch_access_event(
agreement_id,
escrow_reward_condition.fulfillEscrowRewardCondition,
None,
(agreement_id, service_agreement,
price, consumer_address, publisher_account, condition_ids),
conditions_dict['accessSecretStore'].timeout
)
events_manager.watch_reward_event(
agreement_id,
verify_reward_condition.verifyRewardTokens,
None,
(agreement_id, did, service_agreement,
price, consumer_address, publisher_account),
conditions_dict['escrowReward'].timeout
) | python | def process_agreement_events_publisher(publisher_account, agreement_id, did, service_agreement,
price, consumer_address, condition_ids):
"""
Process the agreement events during the register of the service agreement for the publisher side
:param publisher_account: Account instance of the publisher
:param agreement_id: id of the agreement, hex str
:param did: DID, str
:param service_agreement: ServiceAgreement instance
:param price: Asset price, int
:param consumer_address: ethereum account address of consumer, hex str
:param condition_ids: is a list of bytes32 content-addressed Condition IDs, bytes32
:return:
"""
conditions_dict = service_agreement.condition_by_name
events_manager = EventsManager.get_instance(Keeper.get_instance())
events_manager.watch_lock_reward_event(
agreement_id,
access_secret_store_condition.fulfillAccessSecretStoreCondition,
None,
(agreement_id, did, service_agreement,
consumer_address, publisher_account),
conditions_dict['lockReward'].timeout
)
events_manager.watch_access_event(
agreement_id,
escrow_reward_condition.fulfillEscrowRewardCondition,
None,
(agreement_id, service_agreement,
price, consumer_address, publisher_account, condition_ids),
conditions_dict['accessSecretStore'].timeout
)
events_manager.watch_reward_event(
agreement_id,
verify_reward_condition.verifyRewardTokens,
None,
(agreement_id, did, service_agreement,
price, consumer_address, publisher_account),
conditions_dict['escrowReward'].timeout
) | [
"def",
"process_agreement_events_publisher",
"(",
"publisher_account",
",",
"agreement_id",
",",
"did",
",",
"service_agreement",
",",
"price",
",",
"consumer_address",
",",
"condition_ids",
")",
":",
"conditions_dict",
"=",
"service_agreement",
".",
"condition_by_name",
"events_manager",
"=",
"EventsManager",
".",
"get_instance",
"(",
"Keeper",
".",
"get_instance",
"(",
")",
")",
"events_manager",
".",
"watch_lock_reward_event",
"(",
"agreement_id",
",",
"access_secret_store_condition",
".",
"fulfillAccessSecretStoreCondition",
",",
"None",
",",
"(",
"agreement_id",
",",
"did",
",",
"service_agreement",
",",
"consumer_address",
",",
"publisher_account",
")",
",",
"conditions_dict",
"[",
"'lockReward'",
"]",
".",
"timeout",
")",
"events_manager",
".",
"watch_access_event",
"(",
"agreement_id",
",",
"escrow_reward_condition",
".",
"fulfillEscrowRewardCondition",
",",
"None",
",",
"(",
"agreement_id",
",",
"service_agreement",
",",
"price",
",",
"consumer_address",
",",
"publisher_account",
",",
"condition_ids",
")",
",",
"conditions_dict",
"[",
"'accessSecretStore'",
"]",
".",
"timeout",
")",
"events_manager",
".",
"watch_reward_event",
"(",
"agreement_id",
",",
"verify_reward_condition",
".",
"verifyRewardTokens",
",",
"None",
",",
"(",
"agreement_id",
",",
"did",
",",
"service_agreement",
",",
"price",
",",
"consumer_address",
",",
"publisher_account",
")",
",",
"conditions_dict",
"[",
"'escrowReward'",
"]",
".",
"timeout",
")"
] | Process the agreement events during the register of the service agreement for the publisher side
:param publisher_account: Account instance of the publisher
:param agreement_id: id of the agreement, hex str
:param did: DID, str
:param service_agreement: ServiceAgreement instance
:param price: Asset price, int
:param consumer_address: ethereum account address of consumer, hex str
:param condition_ids: is a list of bytes32 content-addressed Condition IDs, bytes32
:return: | [
"Process",
"the",
"agreement",
"events",
"during",
"the",
"register",
"of",
"the",
"service",
"agreement",
"for",
"the",
"publisher",
"side"
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/agreements/register_service_agreement.py#L130-L171 | train | 235,404 |
oceanprotocol/squid-py | squid_py/agreements/register_service_agreement.py | execute_pending_service_agreements | def execute_pending_service_agreements(storage_path, account, actor_type, did_resolver_fn):
"""
Iterates over pending service agreements recorded in the local storage,
fetches their service definitions, and subscribes to service agreement events.
:param storage_path: storage path for the internal db, str
:param account:
:param actor_type:
:param did_resolver_fn:
:return:
"""
keeper = Keeper.get_instance()
# service_agreement_id, did, service_definition_id, price, files, start_time, status
for (agreement_id, did, _,
price, files, start_time, _) in get_service_agreements(storage_path):
ddo = did_resolver_fn(did)
for service in ddo.services:
if service.type != 'Access':
continue
consumer_provider_tuple = keeper.escrow_access_secretstore_template.get_agreement_data(
agreement_id)
if not consumer_provider_tuple:
continue
consumer, provider = consumer_provider_tuple
did = ddo.did
service_agreement = ServiceAgreement.from_service_dict(service.as_dictionary())
condition_ids = service_agreement.generate_agreement_condition_ids(
agreement_id, did, consumer, provider, keeper)
if actor_type == 'consumer':
assert account.address == consumer
process_agreement_events_consumer(
provider, agreement_id, did, service_agreement,
price, account, condition_ids, None)
else:
assert account.address == provider
process_agreement_events_publisher(
account, agreement_id, did, service_agreement,
price, consumer, condition_ids) | python | def execute_pending_service_agreements(storage_path, account, actor_type, did_resolver_fn):
"""
Iterates over pending service agreements recorded in the local storage,
fetches their service definitions, and subscribes to service agreement events.
:param storage_path: storage path for the internal db, str
:param account:
:param actor_type:
:param did_resolver_fn:
:return:
"""
keeper = Keeper.get_instance()
# service_agreement_id, did, service_definition_id, price, files, start_time, status
for (agreement_id, did, _,
price, files, start_time, _) in get_service_agreements(storage_path):
ddo = did_resolver_fn(did)
for service in ddo.services:
if service.type != 'Access':
continue
consumer_provider_tuple = keeper.escrow_access_secretstore_template.get_agreement_data(
agreement_id)
if not consumer_provider_tuple:
continue
consumer, provider = consumer_provider_tuple
did = ddo.did
service_agreement = ServiceAgreement.from_service_dict(service.as_dictionary())
condition_ids = service_agreement.generate_agreement_condition_ids(
agreement_id, did, consumer, provider, keeper)
if actor_type == 'consumer':
assert account.address == consumer
process_agreement_events_consumer(
provider, agreement_id, did, service_agreement,
price, account, condition_ids, None)
else:
assert account.address == provider
process_agreement_events_publisher(
account, agreement_id, did, service_agreement,
price, consumer, condition_ids) | [
"def",
"execute_pending_service_agreements",
"(",
"storage_path",
",",
"account",
",",
"actor_type",
",",
"did_resolver_fn",
")",
":",
"keeper",
"=",
"Keeper",
".",
"get_instance",
"(",
")",
"# service_agreement_id, did, service_definition_id, price, files, start_time, status",
"for",
"(",
"agreement_id",
",",
"did",
",",
"_",
",",
"price",
",",
"files",
",",
"start_time",
",",
"_",
")",
"in",
"get_service_agreements",
"(",
"storage_path",
")",
":",
"ddo",
"=",
"did_resolver_fn",
"(",
"did",
")",
"for",
"service",
"in",
"ddo",
".",
"services",
":",
"if",
"service",
".",
"type",
"!=",
"'Access'",
":",
"continue",
"consumer_provider_tuple",
"=",
"keeper",
".",
"escrow_access_secretstore_template",
".",
"get_agreement_data",
"(",
"agreement_id",
")",
"if",
"not",
"consumer_provider_tuple",
":",
"continue",
"consumer",
",",
"provider",
"=",
"consumer_provider_tuple",
"did",
"=",
"ddo",
".",
"did",
"service_agreement",
"=",
"ServiceAgreement",
".",
"from_service_dict",
"(",
"service",
".",
"as_dictionary",
"(",
")",
")",
"condition_ids",
"=",
"service_agreement",
".",
"generate_agreement_condition_ids",
"(",
"agreement_id",
",",
"did",
",",
"consumer",
",",
"provider",
",",
"keeper",
")",
"if",
"actor_type",
"==",
"'consumer'",
":",
"assert",
"account",
".",
"address",
"==",
"consumer",
"process_agreement_events_consumer",
"(",
"provider",
",",
"agreement_id",
",",
"did",
",",
"service_agreement",
",",
"price",
",",
"account",
",",
"condition_ids",
",",
"None",
")",
"else",
":",
"assert",
"account",
".",
"address",
"==",
"provider",
"process_agreement_events_publisher",
"(",
"account",
",",
"agreement_id",
",",
"did",
",",
"service_agreement",
",",
"price",
",",
"consumer",
",",
"condition_ids",
")"
] | Iterates over pending service agreements recorded in the local storage,
fetches their service definitions, and subscribes to service agreement events.
:param storage_path: storage path for the internal db, str
:param account:
:param actor_type:
:param did_resolver_fn:
:return: | [
"Iterates",
"over",
"pending",
"service",
"agreements",
"recorded",
"in",
"the",
"local",
"storage",
"fetches",
"their",
"service",
"definitions",
"and",
"subscribes",
"to",
"service",
"agreement",
"events",
"."
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/agreements/register_service_agreement.py#L174-L215 | train | 235,405 |
oceanprotocol/squid-py | squid_py/keeper/utils.py | generate_multi_value_hash | def generate_multi_value_hash(types, values):
"""
Return the hash of the given list of values.
This is equivalent to packing and hashing values in a solidity smart contract
hence the use of `soliditySha3`.
:param types: list of solidity types expressed as strings
:param values: list of values matching the `types` list
:return: bytes
"""
assert len(types) == len(values)
return Web3Provider.get_web3().soliditySha3(
types,
values
) | python | def generate_multi_value_hash(types, values):
"""
Return the hash of the given list of values.
This is equivalent to packing and hashing values in a solidity smart contract
hence the use of `soliditySha3`.
:param types: list of solidity types expressed as strings
:param values: list of values matching the `types` list
:return: bytes
"""
assert len(types) == len(values)
return Web3Provider.get_web3().soliditySha3(
types,
values
) | [
"def",
"generate_multi_value_hash",
"(",
"types",
",",
"values",
")",
":",
"assert",
"len",
"(",
"types",
")",
"==",
"len",
"(",
"values",
")",
"return",
"Web3Provider",
".",
"get_web3",
"(",
")",
".",
"soliditySha3",
"(",
"types",
",",
"values",
")"
] | Return the hash of the given list of values.
This is equivalent to packing and hashing values in a solidity smart contract
hence the use of `soliditySha3`.
:param types: list of solidity types expressed as strings
:param values: list of values matching the `types` list
:return: bytes | [
"Return",
"the",
"hash",
"of",
"the",
"given",
"list",
"of",
"values",
".",
"This",
"is",
"equivalent",
"to",
"packing",
"and",
"hashing",
"values",
"in",
"a",
"solidity",
"smart",
"contract",
"hence",
"the",
"use",
"of",
"soliditySha3",
"."
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/keeper/utils.py#L14-L28 | train | 235,406 |
oceanprotocol/squid-py | squid_py/keeper/utils.py | process_tx_receipt | def process_tx_receipt(tx_hash, event, event_name):
"""
Wait until the tx receipt is processed.
:param tx_hash: hash of the transaction
:param event: AttributeDict with the event data.
:param event_name: name of the event to subscribe, str
:return:
"""
web3 = Web3Provider.get_web3()
try:
web3.eth.waitForTransactionReceipt(tx_hash, timeout=20)
except Timeout:
logger.info('Waiting for transaction receipt timed out. Cannot verify receipt and event.')
return
receipt = web3.eth.getTransactionReceipt(tx_hash)
event = event().processReceipt(receipt)
if event:
logger.info(f'Success: got {event_name} event after fulfilling condition.')
logger.debug(
f'Success: got {event_name} event after fulfilling condition. {receipt}, ::: {event}')
else:
logger.debug(f'Something is not right, cannot find the {event_name} event after calling the'
f' fulfillment condition. This is the transaction receipt {receipt}')
if receipt and receipt.status == 0:
logger.warning(
f'Transaction failed: tx_hash {tx_hash}, tx event {event_name}, receipt {receipt}') | python | def process_tx_receipt(tx_hash, event, event_name):
"""
Wait until the tx receipt is processed.
:param tx_hash: hash of the transaction
:param event: AttributeDict with the event data.
:param event_name: name of the event to subscribe, str
:return:
"""
web3 = Web3Provider.get_web3()
try:
web3.eth.waitForTransactionReceipt(tx_hash, timeout=20)
except Timeout:
logger.info('Waiting for transaction receipt timed out. Cannot verify receipt and event.')
return
receipt = web3.eth.getTransactionReceipt(tx_hash)
event = event().processReceipt(receipt)
if event:
logger.info(f'Success: got {event_name} event after fulfilling condition.')
logger.debug(
f'Success: got {event_name} event after fulfilling condition. {receipt}, ::: {event}')
else:
logger.debug(f'Something is not right, cannot find the {event_name} event after calling the'
f' fulfillment condition. This is the transaction receipt {receipt}')
if receipt and receipt.status == 0:
logger.warning(
f'Transaction failed: tx_hash {tx_hash}, tx event {event_name}, receipt {receipt}') | [
"def",
"process_tx_receipt",
"(",
"tx_hash",
",",
"event",
",",
"event_name",
")",
":",
"web3",
"=",
"Web3Provider",
".",
"get_web3",
"(",
")",
"try",
":",
"web3",
".",
"eth",
".",
"waitForTransactionReceipt",
"(",
"tx_hash",
",",
"timeout",
"=",
"20",
")",
"except",
"Timeout",
":",
"logger",
".",
"info",
"(",
"'Waiting for transaction receipt timed out. Cannot verify receipt and event.'",
")",
"return",
"receipt",
"=",
"web3",
".",
"eth",
".",
"getTransactionReceipt",
"(",
"tx_hash",
")",
"event",
"=",
"event",
"(",
")",
".",
"processReceipt",
"(",
"receipt",
")",
"if",
"event",
":",
"logger",
".",
"info",
"(",
"f'Success: got {event_name} event after fulfilling condition.'",
")",
"logger",
".",
"debug",
"(",
"f'Success: got {event_name} event after fulfilling condition. {receipt}, ::: {event}'",
")",
"else",
":",
"logger",
".",
"debug",
"(",
"f'Something is not right, cannot find the {event_name} event after calling the'",
"f' fulfillment condition. This is the transaction receipt {receipt}'",
")",
"if",
"receipt",
"and",
"receipt",
".",
"status",
"==",
"0",
":",
"logger",
".",
"warning",
"(",
"f'Transaction failed: tx_hash {tx_hash}, tx event {event_name}, receipt {receipt}'",
")"
] | Wait until the tx receipt is processed.
:param tx_hash: hash of the transaction
:param event: AttributeDict with the event data.
:param event_name: name of the event to subscribe, str
:return: | [
"Wait",
"until",
"the",
"tx",
"receipt",
"is",
"processed",
"."
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/keeper/utils.py#L31-L59 | train | 235,407 |
oceanprotocol/squid-py | squid_py/keeper/conditions/condition_manager.py | ConditionStoreManager.get_condition | def get_condition(self, condition_id):
"""Retrieve the condition for a condition_id.
:param condition_id: id of the condition, str
:return:
"""
condition = self.contract_concise.getCondition(condition_id)
if condition and len(condition) == 7:
return ConditionValues(*condition)
return None | python | def get_condition(self, condition_id):
"""Retrieve the condition for a condition_id.
:param condition_id: id of the condition, str
:return:
"""
condition = self.contract_concise.getCondition(condition_id)
if condition and len(condition) == 7:
return ConditionValues(*condition)
return None | [
"def",
"get_condition",
"(",
"self",
",",
"condition_id",
")",
":",
"condition",
"=",
"self",
".",
"contract_concise",
".",
"getCondition",
"(",
"condition_id",
")",
"if",
"condition",
"and",
"len",
"(",
"condition",
")",
"==",
"7",
":",
"return",
"ConditionValues",
"(",
"*",
"condition",
")",
"return",
"None"
] | Retrieve the condition for a condition_id.
:param condition_id: id of the condition, str
:return: | [
"Retrieve",
"the",
"condition",
"for",
"a",
"condition_id",
"."
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/keeper/conditions/condition_manager.py#L19-L29 | train | 235,408 |
oceanprotocol/squid-py | squid_py/keeper/conditions/sign.py | SignCondition.fulfill | def fulfill(self, agreement_id, message, account_address, signature, from_account):
"""
Fulfill the sign conditon.
:param agreement_id: id of the agreement, hex str
:param message:
:param account_address: ethereum account address, hex str
:param signature: signed agreement hash, hex str
:param from_account: Account doing the transaction
:return:
"""
return self._fulfill(
agreement_id,
message,
account_address,
signature,
transact={'from': from_account.address,
'passphrase': from_account.password}
) | python | def fulfill(self, agreement_id, message, account_address, signature, from_account):
"""
Fulfill the sign conditon.
:param agreement_id: id of the agreement, hex str
:param message:
:param account_address: ethereum account address, hex str
:param signature: signed agreement hash, hex str
:param from_account: Account doing the transaction
:return:
"""
return self._fulfill(
agreement_id,
message,
account_address,
signature,
transact={'from': from_account.address,
'passphrase': from_account.password}
) | [
"def",
"fulfill",
"(",
"self",
",",
"agreement_id",
",",
"message",
",",
"account_address",
",",
"signature",
",",
"from_account",
")",
":",
"return",
"self",
".",
"_fulfill",
"(",
"agreement_id",
",",
"message",
",",
"account_address",
",",
"signature",
",",
"transact",
"=",
"{",
"'from'",
":",
"from_account",
".",
"address",
",",
"'passphrase'",
":",
"from_account",
".",
"password",
"}",
")"
] | Fulfill the sign conditon.
:param agreement_id: id of the agreement, hex str
:param message:
:param account_address: ethereum account address, hex str
:param signature: signed agreement hash, hex str
:param from_account: Account doing the transaction
:return: | [
"Fulfill",
"the",
"sign",
"conditon",
"."
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/keeper/conditions/sign.py#L11-L29 | train | 235,409 |
oceanprotocol/squid-py | squid_py/ocean/ocean_agreements.py | OceanAgreements.create | def create(self, did, service_definition_id, agreement_id,
service_agreement_signature, consumer_address, account):
"""
Execute the service agreement on-chain using keeper's ServiceAgreement contract.
The on-chain executeAgreement method requires the following arguments:
templateId, signature, consumer, hashes, timeouts, serviceAgreementId, did.
`agreement_message_hash` is necessary to verify the signature.
The consumer `signature` includes the conditions timeouts and parameters values which
is usedon-chain to verify that the values actually match the signed hashes.
:param did: str representation fo the asset DID. Use this to retrieve the asset DDO.
:param service_definition_id: str identifies the specific service in
the ddo to use in this agreement.
:param agreement_id: 32 bytes identifier created by the consumer and will be used
on-chain for the executed agreement.
:param service_agreement_signature: str the signed agreement message hash which includes
conditions and their parameters values and other details of the agreement.
:param consumer_address: ethereum account address of consumer, hex str
:param account: Account instance creating the agreement. Can be either the
consumer, publisher or provider
:return: dict the `executeAgreement` transaction receipt
"""
assert consumer_address and Web3Provider.get_web3().isChecksumAddress(
consumer_address), f'Invalid consumer address {consumer_address}'
assert account.address in self._keeper.accounts, \
f'Unrecognized account address {account.address}'
agreement_template_approved = self._keeper.template_manager.is_template_approved(
self._keeper.escrow_access_secretstore_template.address)
if not agreement_template_approved:
msg = (f'The EscrowAccessSecretStoreTemplate contract at address '
f'{self._keeper.escrow_access_secretstore_template.address} is not '
f'approved and cannot be used for creating service agreements.')
logger.warning(msg)
raise OceanInvalidAgreementTemplate(msg)
asset = self._asset_resolver.resolve(did)
asset_id = asset.asset_id
service_agreement = ServiceAgreement.from_ddo(service_definition_id, asset)
agreement_template = self._keeper.escrow_access_secretstore_template
if agreement_template.get_agreement_consumer(agreement_id) is not None:
raise OceanServiceAgreementExists(
f'Service agreement {agreement_id} already exists, cannot reuse '
f'the same agreement id.')
if consumer_address != account.address:
if not self._verify_service_agreement_signature(
did, agreement_id, service_definition_id,
consumer_address, service_agreement_signature,
ddo=asset
):
raise OceanInvalidServiceAgreementSignature(
f'Verifying consumer signature failed: '
f'signature {service_agreement_signature}, '
f'consumerAddress {consumer_address}'
)
publisher_address = Web3Provider.get_web3().toChecksumAddress(asset.publisher)
condition_ids = service_agreement.generate_agreement_condition_ids(
agreement_id, asset_id, consumer_address, publisher_address, self._keeper)
time_locks = service_agreement.conditions_timelocks
time_outs = service_agreement.conditions_timeouts
success = agreement_template.create_agreement(
agreement_id,
asset_id,
condition_ids,
time_locks,
time_outs,
consumer_address,
account
)
if not success:
# success is based on tx receipt which is not reliable.
# So we check on-chain directly to see if agreement_id is there
consumer = self._keeper.escrow_access_secretstore_template.get_agreement_consumer(agreement_id)
if consumer:
success = True
else:
event_log = self._keeper.escrow_access_secretstore_template.subscribe_agreement_created(
agreement_id, 30, None, (), wait=True
)
success = event_log is not None
if success:
logger.info(f'Service agreement {agreement_id} created successfully.')
else:
logger.info(f'Create agreement "{agreement_id}" failed.')
self._log_agreement_info(
asset, service_agreement, agreement_id, service_agreement_signature,
consumer_address, account, condition_ids
)
if success:
# subscribe to events related to this agreement_id
if consumer_address == account.address:
register_service_agreement_consumer(
self._config.storage_path,
publisher_address,
agreement_id,
did,
service_agreement,
service_definition_id,
service_agreement.get_price(),
asset.encrypted_files,
account,
condition_ids,
None
)
else:
register_service_agreement_publisher(
self._config.storage_path,
consumer_address,
agreement_id,
did,
service_agreement,
service_definition_id,
service_agreement.get_price(),
account,
condition_ids
)
return success | python | def create(self, did, service_definition_id, agreement_id,
service_agreement_signature, consumer_address, account):
"""
Execute the service agreement on-chain using keeper's ServiceAgreement contract.
The on-chain executeAgreement method requires the following arguments:
templateId, signature, consumer, hashes, timeouts, serviceAgreementId, did.
`agreement_message_hash` is necessary to verify the signature.
The consumer `signature` includes the conditions timeouts and parameters values which
is usedon-chain to verify that the values actually match the signed hashes.
:param did: str representation fo the asset DID. Use this to retrieve the asset DDO.
:param service_definition_id: str identifies the specific service in
the ddo to use in this agreement.
:param agreement_id: 32 bytes identifier created by the consumer and will be used
on-chain for the executed agreement.
:param service_agreement_signature: str the signed agreement message hash which includes
conditions and their parameters values and other details of the agreement.
:param consumer_address: ethereum account address of consumer, hex str
:param account: Account instance creating the agreement. Can be either the
consumer, publisher or provider
:return: dict the `executeAgreement` transaction receipt
"""
assert consumer_address and Web3Provider.get_web3().isChecksumAddress(
consumer_address), f'Invalid consumer address {consumer_address}'
assert account.address in self._keeper.accounts, \
f'Unrecognized account address {account.address}'
agreement_template_approved = self._keeper.template_manager.is_template_approved(
self._keeper.escrow_access_secretstore_template.address)
if not agreement_template_approved:
msg = (f'The EscrowAccessSecretStoreTemplate contract at address '
f'{self._keeper.escrow_access_secretstore_template.address} is not '
f'approved and cannot be used for creating service agreements.')
logger.warning(msg)
raise OceanInvalidAgreementTemplate(msg)
asset = self._asset_resolver.resolve(did)
asset_id = asset.asset_id
service_agreement = ServiceAgreement.from_ddo(service_definition_id, asset)
agreement_template = self._keeper.escrow_access_secretstore_template
if agreement_template.get_agreement_consumer(agreement_id) is not None:
raise OceanServiceAgreementExists(
f'Service agreement {agreement_id} already exists, cannot reuse '
f'the same agreement id.')
if consumer_address != account.address:
if not self._verify_service_agreement_signature(
did, agreement_id, service_definition_id,
consumer_address, service_agreement_signature,
ddo=asset
):
raise OceanInvalidServiceAgreementSignature(
f'Verifying consumer signature failed: '
f'signature {service_agreement_signature}, '
f'consumerAddress {consumer_address}'
)
publisher_address = Web3Provider.get_web3().toChecksumAddress(asset.publisher)
condition_ids = service_agreement.generate_agreement_condition_ids(
agreement_id, asset_id, consumer_address, publisher_address, self._keeper)
time_locks = service_agreement.conditions_timelocks
time_outs = service_agreement.conditions_timeouts
success = agreement_template.create_agreement(
agreement_id,
asset_id,
condition_ids,
time_locks,
time_outs,
consumer_address,
account
)
if not success:
# success is based on tx receipt which is not reliable.
# So we check on-chain directly to see if agreement_id is there
consumer = self._keeper.escrow_access_secretstore_template.get_agreement_consumer(agreement_id)
if consumer:
success = True
else:
event_log = self._keeper.escrow_access_secretstore_template.subscribe_agreement_created(
agreement_id, 30, None, (), wait=True
)
success = event_log is not None
if success:
logger.info(f'Service agreement {agreement_id} created successfully.')
else:
logger.info(f'Create agreement "{agreement_id}" failed.')
self._log_agreement_info(
asset, service_agreement, agreement_id, service_agreement_signature,
consumer_address, account, condition_ids
)
if success:
# subscribe to events related to this agreement_id
if consumer_address == account.address:
register_service_agreement_consumer(
self._config.storage_path,
publisher_address,
agreement_id,
did,
service_agreement,
service_definition_id,
service_agreement.get_price(),
asset.encrypted_files,
account,
condition_ids,
None
)
else:
register_service_agreement_publisher(
self._config.storage_path,
consumer_address,
agreement_id,
did,
service_agreement,
service_definition_id,
service_agreement.get_price(),
account,
condition_ids
)
return success | [
"def",
"create",
"(",
"self",
",",
"did",
",",
"service_definition_id",
",",
"agreement_id",
",",
"service_agreement_signature",
",",
"consumer_address",
",",
"account",
")",
":",
"assert",
"consumer_address",
"and",
"Web3Provider",
".",
"get_web3",
"(",
")",
".",
"isChecksumAddress",
"(",
"consumer_address",
")",
",",
"f'Invalid consumer address {consumer_address}'",
"assert",
"account",
".",
"address",
"in",
"self",
".",
"_keeper",
".",
"accounts",
",",
"f'Unrecognized account address {account.address}'",
"agreement_template_approved",
"=",
"self",
".",
"_keeper",
".",
"template_manager",
".",
"is_template_approved",
"(",
"self",
".",
"_keeper",
".",
"escrow_access_secretstore_template",
".",
"address",
")",
"if",
"not",
"agreement_template_approved",
":",
"msg",
"=",
"(",
"f'The EscrowAccessSecretStoreTemplate contract at address '",
"f'{self._keeper.escrow_access_secretstore_template.address} is not '",
"f'approved and cannot be used for creating service agreements.'",
")",
"logger",
".",
"warning",
"(",
"msg",
")",
"raise",
"OceanInvalidAgreementTemplate",
"(",
"msg",
")",
"asset",
"=",
"self",
".",
"_asset_resolver",
".",
"resolve",
"(",
"did",
")",
"asset_id",
"=",
"asset",
".",
"asset_id",
"service_agreement",
"=",
"ServiceAgreement",
".",
"from_ddo",
"(",
"service_definition_id",
",",
"asset",
")",
"agreement_template",
"=",
"self",
".",
"_keeper",
".",
"escrow_access_secretstore_template",
"if",
"agreement_template",
".",
"get_agreement_consumer",
"(",
"agreement_id",
")",
"is",
"not",
"None",
":",
"raise",
"OceanServiceAgreementExists",
"(",
"f'Service agreement {agreement_id} already exists, cannot reuse '",
"f'the same agreement id.'",
")",
"if",
"consumer_address",
"!=",
"account",
".",
"address",
":",
"if",
"not",
"self",
".",
"_verify_service_agreement_signature",
"(",
"did",
",",
"agreement_id",
",",
"service_definition_id",
",",
"consumer_address",
",",
"service_agreement_signature",
",",
"ddo",
"=",
"asset",
")",
":",
"raise",
"OceanInvalidServiceAgreementSignature",
"(",
"f'Verifying consumer signature failed: '",
"f'signature {service_agreement_signature}, '",
"f'consumerAddress {consumer_address}'",
")",
"publisher_address",
"=",
"Web3Provider",
".",
"get_web3",
"(",
")",
".",
"toChecksumAddress",
"(",
"asset",
".",
"publisher",
")",
"condition_ids",
"=",
"service_agreement",
".",
"generate_agreement_condition_ids",
"(",
"agreement_id",
",",
"asset_id",
",",
"consumer_address",
",",
"publisher_address",
",",
"self",
".",
"_keeper",
")",
"time_locks",
"=",
"service_agreement",
".",
"conditions_timelocks",
"time_outs",
"=",
"service_agreement",
".",
"conditions_timeouts",
"success",
"=",
"agreement_template",
".",
"create_agreement",
"(",
"agreement_id",
",",
"asset_id",
",",
"condition_ids",
",",
"time_locks",
",",
"time_outs",
",",
"consumer_address",
",",
"account",
")",
"if",
"not",
"success",
":",
"# success is based on tx receipt which is not reliable.",
"# So we check on-chain directly to see if agreement_id is there",
"consumer",
"=",
"self",
".",
"_keeper",
".",
"escrow_access_secretstore_template",
".",
"get_agreement_consumer",
"(",
"agreement_id",
")",
"if",
"consumer",
":",
"success",
"=",
"True",
"else",
":",
"event_log",
"=",
"self",
".",
"_keeper",
".",
"escrow_access_secretstore_template",
".",
"subscribe_agreement_created",
"(",
"agreement_id",
",",
"30",
",",
"None",
",",
"(",
")",
",",
"wait",
"=",
"True",
")",
"success",
"=",
"event_log",
"is",
"not",
"None",
"if",
"success",
":",
"logger",
".",
"info",
"(",
"f'Service agreement {agreement_id} created successfully.'",
")",
"else",
":",
"logger",
".",
"info",
"(",
"f'Create agreement \"{agreement_id}\" failed.'",
")",
"self",
".",
"_log_agreement_info",
"(",
"asset",
",",
"service_agreement",
",",
"agreement_id",
",",
"service_agreement_signature",
",",
"consumer_address",
",",
"account",
",",
"condition_ids",
")",
"if",
"success",
":",
"# subscribe to events related to this agreement_id",
"if",
"consumer_address",
"==",
"account",
".",
"address",
":",
"register_service_agreement_consumer",
"(",
"self",
".",
"_config",
".",
"storage_path",
",",
"publisher_address",
",",
"agreement_id",
",",
"did",
",",
"service_agreement",
",",
"service_definition_id",
",",
"service_agreement",
".",
"get_price",
"(",
")",
",",
"asset",
".",
"encrypted_files",
",",
"account",
",",
"condition_ids",
",",
"None",
")",
"else",
":",
"register_service_agreement_publisher",
"(",
"self",
".",
"_config",
".",
"storage_path",
",",
"consumer_address",
",",
"agreement_id",
",",
"did",
",",
"service_agreement",
",",
"service_definition_id",
",",
"service_agreement",
".",
"get_price",
"(",
")",
",",
"account",
",",
"condition_ids",
")",
"return",
"success"
] | Execute the service agreement on-chain using keeper's ServiceAgreement contract.
The on-chain executeAgreement method requires the following arguments:
templateId, signature, consumer, hashes, timeouts, serviceAgreementId, did.
`agreement_message_hash` is necessary to verify the signature.
The consumer `signature` includes the conditions timeouts and parameters values which
is usedon-chain to verify that the values actually match the signed hashes.
:param did: str representation fo the asset DID. Use this to retrieve the asset DDO.
:param service_definition_id: str identifies the specific service in
the ddo to use in this agreement.
:param agreement_id: 32 bytes identifier created by the consumer and will be used
on-chain for the executed agreement.
:param service_agreement_signature: str the signed agreement message hash which includes
conditions and their parameters values and other details of the agreement.
:param consumer_address: ethereum account address of consumer, hex str
:param account: Account instance creating the agreement. Can be either the
consumer, publisher or provider
:return: dict the `executeAgreement` transaction receipt | [
"Execute",
"the",
"service",
"agreement",
"on",
"-",
"chain",
"using",
"keeper",
"s",
"ServiceAgreement",
"contract",
"."
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/ocean/ocean_agreements.py#L126-L252 | train | 235,410 |
oceanprotocol/squid-py | squid_py/ocean/ocean_agreements.py | OceanAgreements.is_access_granted | def is_access_granted(self, agreement_id, did, consumer_address):
"""
Check permission for the agreement.
Verify on-chain that the `consumer_address` has permission to access the given asset `did`
according to the `agreement_id`.
:param agreement_id: id of the agreement, hex str
:param did: DID, str
:param consumer_address: ethereum account address of consumer, hex str
:return: bool True if user has permission
"""
agreement_consumer = self._keeper.escrow_access_secretstore_template.get_agreement_consumer(
agreement_id)
if agreement_consumer != consumer_address:
logger.warning(f'Invalid consumer address {consumer_address} and/or '
f'service agreement id {agreement_id} (did {did})'
f', agreement consumer is {agreement_consumer}')
return False
document_id = did_to_id(did)
return self._keeper.access_secret_store_condition.check_permissions(
document_id, consumer_address
) | python | def is_access_granted(self, agreement_id, did, consumer_address):
"""
Check permission for the agreement.
Verify on-chain that the `consumer_address` has permission to access the given asset `did`
according to the `agreement_id`.
:param agreement_id: id of the agreement, hex str
:param did: DID, str
:param consumer_address: ethereum account address of consumer, hex str
:return: bool True if user has permission
"""
agreement_consumer = self._keeper.escrow_access_secretstore_template.get_agreement_consumer(
agreement_id)
if agreement_consumer != consumer_address:
logger.warning(f'Invalid consumer address {consumer_address} and/or '
f'service agreement id {agreement_id} (did {did})'
f', agreement consumer is {agreement_consumer}')
return False
document_id = did_to_id(did)
return self._keeper.access_secret_store_condition.check_permissions(
document_id, consumer_address
) | [
"def",
"is_access_granted",
"(",
"self",
",",
"agreement_id",
",",
"did",
",",
"consumer_address",
")",
":",
"agreement_consumer",
"=",
"self",
".",
"_keeper",
".",
"escrow_access_secretstore_template",
".",
"get_agreement_consumer",
"(",
"agreement_id",
")",
"if",
"agreement_consumer",
"!=",
"consumer_address",
":",
"logger",
".",
"warning",
"(",
"f'Invalid consumer address {consumer_address} and/or '",
"f'service agreement id {agreement_id} (did {did})'",
"f', agreement consumer is {agreement_consumer}'",
")",
"return",
"False",
"document_id",
"=",
"did_to_id",
"(",
"did",
")",
"return",
"self",
".",
"_keeper",
".",
"access_secret_store_condition",
".",
"check_permissions",
"(",
"document_id",
",",
"consumer_address",
")"
] | Check permission for the agreement.
Verify on-chain that the `consumer_address` has permission to access the given asset `did`
according to the `agreement_id`.
:param agreement_id: id of the agreement, hex str
:param did: DID, str
:param consumer_address: ethereum account address of consumer, hex str
:return: bool True if user has permission | [
"Check",
"permission",
"for",
"the",
"agreement",
"."
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/ocean/ocean_agreements.py#L273-L296 | train | 235,411 |
oceanprotocol/squid-py | squid_py/ocean/ocean_agreements.py | OceanAgreements._verify_service_agreement_signature | def _verify_service_agreement_signature(self, did, agreement_id, service_definition_id,
consumer_address, signature, ddo=None):
"""
Verify service agreement signature.
Verify that the given signature is truly signed by the `consumer_address`
and represents this did's service agreement..
:param did: DID, str
:param agreement_id: id of the agreement, hex str
:param service_definition_id: identifier of the service inside the asset DDO, str
:param consumer_address: ethereum account address of consumer, hex str
:param signature: Signature, str
:param ddo: DDO instance
:return: True if signature is legitimate, False otherwise
:raises: ValueError if service is not found in the ddo
:raises: AssertionError if conditions keys do not match the on-chain conditions keys
"""
if not ddo:
ddo = self._asset_resolver.resolve(did)
service_agreement = ServiceAgreement.from_ddo(service_definition_id, ddo)
agreement_hash = service_agreement.get_service_agreement_hash(
agreement_id, ddo.asset_id, consumer_address,
Web3Provider.get_web3().toChecksumAddress(ddo.proof['creator']), self._keeper)
prefixed_hash = prepare_prefixed_hash(agreement_hash)
recovered_address = Web3Provider.get_web3().eth.account.recoverHash(
prefixed_hash, signature=signature
)
is_valid = (recovered_address == consumer_address)
if not is_valid:
logger.warning(f'Agreement signature failed: agreement hash is {agreement_hash.hex()}')
return is_valid | python | def _verify_service_agreement_signature(self, did, agreement_id, service_definition_id,
consumer_address, signature, ddo=None):
"""
Verify service agreement signature.
Verify that the given signature is truly signed by the `consumer_address`
and represents this did's service agreement..
:param did: DID, str
:param agreement_id: id of the agreement, hex str
:param service_definition_id: identifier of the service inside the asset DDO, str
:param consumer_address: ethereum account address of consumer, hex str
:param signature: Signature, str
:param ddo: DDO instance
:return: True if signature is legitimate, False otherwise
:raises: ValueError if service is not found in the ddo
:raises: AssertionError if conditions keys do not match the on-chain conditions keys
"""
if not ddo:
ddo = self._asset_resolver.resolve(did)
service_agreement = ServiceAgreement.from_ddo(service_definition_id, ddo)
agreement_hash = service_agreement.get_service_agreement_hash(
agreement_id, ddo.asset_id, consumer_address,
Web3Provider.get_web3().toChecksumAddress(ddo.proof['creator']), self._keeper)
prefixed_hash = prepare_prefixed_hash(agreement_hash)
recovered_address = Web3Provider.get_web3().eth.account.recoverHash(
prefixed_hash, signature=signature
)
is_valid = (recovered_address == consumer_address)
if not is_valid:
logger.warning(f'Agreement signature failed: agreement hash is {agreement_hash.hex()}')
return is_valid | [
"def",
"_verify_service_agreement_signature",
"(",
"self",
",",
"did",
",",
"agreement_id",
",",
"service_definition_id",
",",
"consumer_address",
",",
"signature",
",",
"ddo",
"=",
"None",
")",
":",
"if",
"not",
"ddo",
":",
"ddo",
"=",
"self",
".",
"_asset_resolver",
".",
"resolve",
"(",
"did",
")",
"service_agreement",
"=",
"ServiceAgreement",
".",
"from_ddo",
"(",
"service_definition_id",
",",
"ddo",
")",
"agreement_hash",
"=",
"service_agreement",
".",
"get_service_agreement_hash",
"(",
"agreement_id",
",",
"ddo",
".",
"asset_id",
",",
"consumer_address",
",",
"Web3Provider",
".",
"get_web3",
"(",
")",
".",
"toChecksumAddress",
"(",
"ddo",
".",
"proof",
"[",
"'creator'",
"]",
")",
",",
"self",
".",
"_keeper",
")",
"prefixed_hash",
"=",
"prepare_prefixed_hash",
"(",
"agreement_hash",
")",
"recovered_address",
"=",
"Web3Provider",
".",
"get_web3",
"(",
")",
".",
"eth",
".",
"account",
".",
"recoverHash",
"(",
"prefixed_hash",
",",
"signature",
"=",
"signature",
")",
"is_valid",
"=",
"(",
"recovered_address",
"==",
"consumer_address",
")",
"if",
"not",
"is_valid",
":",
"logger",
".",
"warning",
"(",
"f'Agreement signature failed: agreement hash is {agreement_hash.hex()}'",
")",
"return",
"is_valid"
] | Verify service agreement signature.
Verify that the given signature is truly signed by the `consumer_address`
and represents this did's service agreement..
:param did: DID, str
:param agreement_id: id of the agreement, hex str
:param service_definition_id: identifier of the service inside the asset DDO, str
:param consumer_address: ethereum account address of consumer, hex str
:param signature: Signature, str
:param ddo: DDO instance
:return: True if signature is legitimate, False otherwise
:raises: ValueError if service is not found in the ddo
:raises: AssertionError if conditions keys do not match the on-chain conditions keys | [
"Verify",
"service",
"agreement",
"signature",
"."
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/ocean/ocean_agreements.py#L298-L332 | train | 235,412 |
oceanprotocol/squid-py | squid_py/ocean/ocean_agreements.py | OceanAgreements.status | def status(self, agreement_id):
"""
Get the status of a service agreement.
:param agreement_id: id of the agreement, hex str
:return: dict with condition status of each of the agreement's conditions or None if the
agreement is invalid.
"""
condition_ids = self._keeper.agreement_manager.get_agreement(agreement_id).condition_ids
result = {"agreementId": agreement_id}
conditions = dict()
for i in condition_ids:
conditions[self._keeper.get_condition_name_by_address(
self._keeper.condition_manager.get_condition(
i).type_ref)] = self._keeper.condition_manager.get_condition_state(i)
result["conditions"] = conditions
return result | python | def status(self, agreement_id):
"""
Get the status of a service agreement.
:param agreement_id: id of the agreement, hex str
:return: dict with condition status of each of the agreement's conditions or None if the
agreement is invalid.
"""
condition_ids = self._keeper.agreement_manager.get_agreement(agreement_id).condition_ids
result = {"agreementId": agreement_id}
conditions = dict()
for i in condition_ids:
conditions[self._keeper.get_condition_name_by_address(
self._keeper.condition_manager.get_condition(
i).type_ref)] = self._keeper.condition_manager.get_condition_state(i)
result["conditions"] = conditions
return result | [
"def",
"status",
"(",
"self",
",",
"agreement_id",
")",
":",
"condition_ids",
"=",
"self",
".",
"_keeper",
".",
"agreement_manager",
".",
"get_agreement",
"(",
"agreement_id",
")",
".",
"condition_ids",
"result",
"=",
"{",
"\"agreementId\"",
":",
"agreement_id",
"}",
"conditions",
"=",
"dict",
"(",
")",
"for",
"i",
"in",
"condition_ids",
":",
"conditions",
"[",
"self",
".",
"_keeper",
".",
"get_condition_name_by_address",
"(",
"self",
".",
"_keeper",
".",
"condition_manager",
".",
"get_condition",
"(",
"i",
")",
".",
"type_ref",
")",
"]",
"=",
"self",
".",
"_keeper",
".",
"condition_manager",
".",
"get_condition_state",
"(",
"i",
")",
"result",
"[",
"\"conditions\"",
"]",
"=",
"conditions",
"return",
"result"
] | Get the status of a service agreement.
:param agreement_id: id of the agreement, hex str
:return: dict with condition status of each of the agreement's conditions or None if the
agreement is invalid. | [
"Get",
"the",
"status",
"of",
"a",
"service",
"agreement",
"."
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/ocean/ocean_agreements.py#L343-L359 | train | 235,413 |
oceanprotocol/squid-py | squid_py/keeper/templates/access_secret_store_template.py | EscrowAccessSecretStoreTemplate.create_agreement | def create_agreement(self, agreement_id, did, condition_ids, time_locks, time_outs,
consumer_address, account):
"""
Create the service agreement. Return true if it is created successfully.
:param agreement_id: id of the agreement, hex str
:param did: DID, str
:param condition_ids: is a list of bytes32 content-addressed Condition IDs, bytes32
:param time_locks: is a list of uint time lock values associated to each Condition, int
:param time_outs: is a list of uint time out values associated to each Condition, int
:param consumer_address: ethereum account address of consumer, hex str
:param account: Account instance creating the agreement
:return: bool
"""
logger.info(
f'Creating agreement {agreement_id} with did={did}, consumer={consumer_address}.')
tx_hash = self.send_transaction(
'createAgreement',
(agreement_id,
did,
condition_ids,
time_locks,
time_outs,
consumer_address),
transact={'from': account.address,
'passphrase': account.password}
)
receipt = self.get_tx_receipt(tx_hash)
return receipt and receipt.status == 1 | python | def create_agreement(self, agreement_id, did, condition_ids, time_locks, time_outs,
consumer_address, account):
"""
Create the service agreement. Return true if it is created successfully.
:param agreement_id: id of the agreement, hex str
:param did: DID, str
:param condition_ids: is a list of bytes32 content-addressed Condition IDs, bytes32
:param time_locks: is a list of uint time lock values associated to each Condition, int
:param time_outs: is a list of uint time out values associated to each Condition, int
:param consumer_address: ethereum account address of consumer, hex str
:param account: Account instance creating the agreement
:return: bool
"""
logger.info(
f'Creating agreement {agreement_id} with did={did}, consumer={consumer_address}.')
tx_hash = self.send_transaction(
'createAgreement',
(agreement_id,
did,
condition_ids,
time_locks,
time_outs,
consumer_address),
transact={'from': account.address,
'passphrase': account.password}
)
receipt = self.get_tx_receipt(tx_hash)
return receipt and receipt.status == 1 | [
"def",
"create_agreement",
"(",
"self",
",",
"agreement_id",
",",
"did",
",",
"condition_ids",
",",
"time_locks",
",",
"time_outs",
",",
"consumer_address",
",",
"account",
")",
":",
"logger",
".",
"info",
"(",
"f'Creating agreement {agreement_id} with did={did}, consumer={consumer_address}.'",
")",
"tx_hash",
"=",
"self",
".",
"send_transaction",
"(",
"'createAgreement'",
",",
"(",
"agreement_id",
",",
"did",
",",
"condition_ids",
",",
"time_locks",
",",
"time_outs",
",",
"consumer_address",
")",
",",
"transact",
"=",
"{",
"'from'",
":",
"account",
".",
"address",
",",
"'passphrase'",
":",
"account",
".",
"password",
"}",
")",
"receipt",
"=",
"self",
".",
"get_tx_receipt",
"(",
"tx_hash",
")",
"return",
"receipt",
"and",
"receipt",
".",
"status",
"==",
"1"
] | Create the service agreement. Return true if it is created successfully.
:param agreement_id: id of the agreement, hex str
:param did: DID, str
:param condition_ids: is a list of bytes32 content-addressed Condition IDs, bytes32
:param time_locks: is a list of uint time lock values associated to each Condition, int
:param time_outs: is a list of uint time out values associated to each Condition, int
:param consumer_address: ethereum account address of consumer, hex str
:param account: Account instance creating the agreement
:return: bool | [
"Create",
"the",
"service",
"agreement",
".",
"Return",
"true",
"if",
"it",
"is",
"created",
"successfully",
"."
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/keeper/templates/access_secret_store_template.py#L17-L45 | train | 235,414 |
oceanprotocol/squid-py | squid_py/keeper/templates/access_secret_store_template.py | EscrowAccessSecretStoreTemplate.subscribe_agreement_created | def subscribe_agreement_created(self, agreement_id, timeout, callback, args, wait=False):
"""
Subscribe to an agreement created.
:param agreement_id: id of the agreement, hex str
:param timeout:
:param callback:
:param args:
:param wait: if true block the listener until get the event, bool
:return:
"""
logger.info(
f'Subscribing {self.AGREEMENT_CREATED_EVENT} event with agreement id {agreement_id}.')
return self.subscribe_to_event(
self.AGREEMENT_CREATED_EVENT,
timeout,
{'_agreementId': Web3Provider.get_web3().toBytes(hexstr=agreement_id)},
callback=callback,
args=args,
wait=wait
) | python | def subscribe_agreement_created(self, agreement_id, timeout, callback, args, wait=False):
"""
Subscribe to an agreement created.
:param agreement_id: id of the agreement, hex str
:param timeout:
:param callback:
:param args:
:param wait: if true block the listener until get the event, bool
:return:
"""
logger.info(
f'Subscribing {self.AGREEMENT_CREATED_EVENT} event with agreement id {agreement_id}.')
return self.subscribe_to_event(
self.AGREEMENT_CREATED_EVENT,
timeout,
{'_agreementId': Web3Provider.get_web3().toBytes(hexstr=agreement_id)},
callback=callback,
args=args,
wait=wait
) | [
"def",
"subscribe_agreement_created",
"(",
"self",
",",
"agreement_id",
",",
"timeout",
",",
"callback",
",",
"args",
",",
"wait",
"=",
"False",
")",
":",
"logger",
".",
"info",
"(",
"f'Subscribing {self.AGREEMENT_CREATED_EVENT} event with agreement id {agreement_id}.'",
")",
"return",
"self",
".",
"subscribe_to_event",
"(",
"self",
".",
"AGREEMENT_CREATED_EVENT",
",",
"timeout",
",",
"{",
"'_agreementId'",
":",
"Web3Provider",
".",
"get_web3",
"(",
")",
".",
"toBytes",
"(",
"hexstr",
"=",
"agreement_id",
")",
"}",
",",
"callback",
"=",
"callback",
",",
"args",
"=",
"args",
",",
"wait",
"=",
"wait",
")"
] | Subscribe to an agreement created.
:param agreement_id: id of the agreement, hex str
:param timeout:
:param callback:
:param args:
:param wait: if true block the listener until get the event, bool
:return: | [
"Subscribe",
"to",
"an",
"agreement",
"created",
"."
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/keeper/templates/access_secret_store_template.py#L72-L92 | train | 235,415 |
oceanprotocol/squid-py | squid_py/keeper/conditions/condition_base.py | ConditionBase.generate_id | def generate_id(self, agreement_id, types, values):
"""
Generate id for the condition.
:param agreement_id: id of the agreement, hex str
:param types: list of types
:param values: list of values
:return: id, str
"""
values_hash = utils.generate_multi_value_hash(types, values)
return utils.generate_multi_value_hash(
['bytes32', 'address', 'bytes32'],
[agreement_id, self.address, values_hash]
) | python | def generate_id(self, agreement_id, types, values):
"""
Generate id for the condition.
:param agreement_id: id of the agreement, hex str
:param types: list of types
:param values: list of values
:return: id, str
"""
values_hash = utils.generate_multi_value_hash(types, values)
return utils.generate_multi_value_hash(
['bytes32', 'address', 'bytes32'],
[agreement_id, self.address, values_hash]
) | [
"def",
"generate_id",
"(",
"self",
",",
"agreement_id",
",",
"types",
",",
"values",
")",
":",
"values_hash",
"=",
"utils",
".",
"generate_multi_value_hash",
"(",
"types",
",",
"values",
")",
"return",
"utils",
".",
"generate_multi_value_hash",
"(",
"[",
"'bytes32'",
",",
"'address'",
",",
"'bytes32'",
"]",
",",
"[",
"agreement_id",
",",
"self",
".",
"address",
",",
"values_hash",
"]",
")"
] | Generate id for the condition.
:param agreement_id: id of the agreement, hex str
:param types: list of types
:param values: list of values
:return: id, str | [
"Generate",
"id",
"for",
"the",
"condition",
"."
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/keeper/conditions/condition_base.py#L16-L29 | train | 235,416 |
oceanprotocol/squid-py | squid_py/keeper/conditions/condition_base.py | ConditionBase._fulfill | def _fulfill(self, *args, **kwargs):
"""
Fulfill the condition.
:param args:
:param kwargs:
:return: true if the condition was successfully fulfilled, bool
"""
tx_hash = self.send_transaction('fulfill', args, **kwargs)
receipt = self.get_tx_receipt(tx_hash)
return receipt.status == 1 | python | def _fulfill(self, *args, **kwargs):
"""
Fulfill the condition.
:param args:
:param kwargs:
:return: true if the condition was successfully fulfilled, bool
"""
tx_hash = self.send_transaction('fulfill', args, **kwargs)
receipt = self.get_tx_receipt(tx_hash)
return receipt.status == 1 | [
"def",
"_fulfill",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"tx_hash",
"=",
"self",
".",
"send_transaction",
"(",
"'fulfill'",
",",
"args",
",",
"*",
"*",
"kwargs",
")",
"receipt",
"=",
"self",
".",
"get_tx_receipt",
"(",
"tx_hash",
")",
"return",
"receipt",
".",
"status",
"==",
"1"
] | Fulfill the condition.
:param args:
:param kwargs:
:return: true if the condition was successfully fulfilled, bool | [
"Fulfill",
"the",
"condition",
"."
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/keeper/conditions/condition_base.py#L31-L41 | train | 235,417 |
oceanprotocol/squid-py | squid_py/keeper/conditions/condition_base.py | ConditionBase.subscribe_condition_fulfilled | def subscribe_condition_fulfilled(self, agreement_id, timeout, callback, args,
timeout_callback=None, wait=False):
"""
Subscribe to the condition fullfilled event.
:param agreement_id: id of the agreement, hex str
:param timeout:
:param callback:
:param args:
:param timeout_callback:
:param wait: if true block the listener until get the event, bool
:return:
"""
logger.info(
f'Subscribing {self.FULFILLED_EVENT} event with agreement id {agreement_id}.')
return self.subscribe_to_event(
self.FULFILLED_EVENT,
timeout,
{'_agreementId': Web3Provider.get_web3().toBytes(hexstr=agreement_id)},
callback=callback,
timeout_callback=timeout_callback,
args=args,
wait=wait
) | python | def subscribe_condition_fulfilled(self, agreement_id, timeout, callback, args,
timeout_callback=None, wait=False):
"""
Subscribe to the condition fullfilled event.
:param agreement_id: id of the agreement, hex str
:param timeout:
:param callback:
:param args:
:param timeout_callback:
:param wait: if true block the listener until get the event, bool
:return:
"""
logger.info(
f'Subscribing {self.FULFILLED_EVENT} event with agreement id {agreement_id}.')
return self.subscribe_to_event(
self.FULFILLED_EVENT,
timeout,
{'_agreementId': Web3Provider.get_web3().toBytes(hexstr=agreement_id)},
callback=callback,
timeout_callback=timeout_callback,
args=args,
wait=wait
) | [
"def",
"subscribe_condition_fulfilled",
"(",
"self",
",",
"agreement_id",
",",
"timeout",
",",
"callback",
",",
"args",
",",
"timeout_callback",
"=",
"None",
",",
"wait",
"=",
"False",
")",
":",
"logger",
".",
"info",
"(",
"f'Subscribing {self.FULFILLED_EVENT} event with agreement id {agreement_id}.'",
")",
"return",
"self",
".",
"subscribe_to_event",
"(",
"self",
".",
"FULFILLED_EVENT",
",",
"timeout",
",",
"{",
"'_agreementId'",
":",
"Web3Provider",
".",
"get_web3",
"(",
")",
".",
"toBytes",
"(",
"hexstr",
"=",
"agreement_id",
")",
"}",
",",
"callback",
"=",
"callback",
",",
"timeout_callback",
"=",
"timeout_callback",
",",
"args",
"=",
"args",
",",
"wait",
"=",
"wait",
")"
] | Subscribe to the condition fullfilled event.
:param agreement_id: id of the agreement, hex str
:param timeout:
:param callback:
:param args:
:param timeout_callback:
:param wait: if true block the listener until get the event, bool
:return: | [
"Subscribe",
"to",
"the",
"condition",
"fullfilled",
"event",
"."
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/keeper/conditions/condition_base.py#L62-L85 | train | 235,418 |
oceanprotocol/squid-py | squid_py/keeper/web3/contract.py | transact_with_contract_function | def transact_with_contract_function(
address,
web3,
function_name=None,
transaction=None,
contract_abi=None,
fn_abi=None,
*args,
**kwargs):
"""
Helper function for interacting with a contract function by sending a
transaction. This is copied from web3 `transact_with_contract_function`
so we can use `personal_sendTransaction` when possible.
"""
transact_transaction = prepare_transaction(
address,
web3,
fn_identifier=function_name,
contract_abi=contract_abi,
transaction=transaction,
fn_abi=fn_abi,
fn_args=args,
fn_kwargs=kwargs,
)
passphrase = None
if transaction and 'passphrase' in transaction:
passphrase = transaction['passphrase']
transact_transaction.pop('passphrase')
if passphrase:
txn_hash = web3.personal.sendTransaction(transact_transaction, passphrase)
else:
txn_hash = web3.eth.sendTransaction(transact_transaction)
return txn_hash | python | def transact_with_contract_function(
address,
web3,
function_name=None,
transaction=None,
contract_abi=None,
fn_abi=None,
*args,
**kwargs):
"""
Helper function for interacting with a contract function by sending a
transaction. This is copied from web3 `transact_with_contract_function`
so we can use `personal_sendTransaction` when possible.
"""
transact_transaction = prepare_transaction(
address,
web3,
fn_identifier=function_name,
contract_abi=contract_abi,
transaction=transaction,
fn_abi=fn_abi,
fn_args=args,
fn_kwargs=kwargs,
)
passphrase = None
if transaction and 'passphrase' in transaction:
passphrase = transaction['passphrase']
transact_transaction.pop('passphrase')
if passphrase:
txn_hash = web3.personal.sendTransaction(transact_transaction, passphrase)
else:
txn_hash = web3.eth.sendTransaction(transact_transaction)
return txn_hash | [
"def",
"transact_with_contract_function",
"(",
"address",
",",
"web3",
",",
"function_name",
"=",
"None",
",",
"transaction",
"=",
"None",
",",
"contract_abi",
"=",
"None",
",",
"fn_abi",
"=",
"None",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"transact_transaction",
"=",
"prepare_transaction",
"(",
"address",
",",
"web3",
",",
"fn_identifier",
"=",
"function_name",
",",
"contract_abi",
"=",
"contract_abi",
",",
"transaction",
"=",
"transaction",
",",
"fn_abi",
"=",
"fn_abi",
",",
"fn_args",
"=",
"args",
",",
"fn_kwargs",
"=",
"kwargs",
",",
")",
"passphrase",
"=",
"None",
"if",
"transaction",
"and",
"'passphrase'",
"in",
"transaction",
":",
"passphrase",
"=",
"transaction",
"[",
"'passphrase'",
"]",
"transact_transaction",
".",
"pop",
"(",
"'passphrase'",
")",
"if",
"passphrase",
":",
"txn_hash",
"=",
"web3",
".",
"personal",
".",
"sendTransaction",
"(",
"transact_transaction",
",",
"passphrase",
")",
"else",
":",
"txn_hash",
"=",
"web3",
".",
"eth",
".",
"sendTransaction",
"(",
"transact_transaction",
")",
"return",
"txn_hash"
] | Helper function for interacting with a contract function by sending a
transaction. This is copied from web3 `transact_with_contract_function`
so we can use `personal_sendTransaction` when possible. | [
"Helper",
"function",
"for",
"interacting",
"with",
"a",
"contract",
"function",
"by",
"sending",
"a",
"transaction",
".",
"This",
"is",
"copied",
"from",
"web3",
"transact_with_contract_function",
"so",
"we",
"can",
"use",
"personal_sendTransaction",
"when",
"possible",
"."
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/keeper/web3/contract.py#L67-L102 | train | 235,419 |
oceanprotocol/squid-py | squid_py/keeper/web3/contract.py | SquidContractFunction.transact | def transact(self, transaction=None):
"""
Customize calling smart contract transaction functions to use `personal_sendTransaction`
instead of `eth_sendTransaction` and to estimate gas limit. This function
is largely copied from web3 ContractFunction with important addition.
Note: will fallback to `eth_sendTransaction` if `passphrase` is not provided in the
`transaction` dict.
:param transaction: dict which has the required transaction arguments per
`personal_sendTransaction` requirements.
:return: hex str transaction hash
"""
if transaction is None:
transact_transaction = {}
else:
transact_transaction = dict(**transaction)
if 'data' in transact_transaction:
raise ValueError("Cannot set data in transact transaction")
cf = self._contract_function
if cf.address is not None:
transact_transaction.setdefault('to', cf.address)
if cf.web3.eth.defaultAccount is not empty:
transact_transaction.setdefault('from', cf.web3.eth.defaultAccount)
if 'to' not in transact_transaction:
if isinstance(self, type):
raise ValueError(
"When using `Contract.transact` from a contract factory you "
"must provide a `to` address with the transaction"
)
else:
raise ValueError(
"Please ensure that this contract instance has an address."
)
if 'gas' not in transact_transaction:
tx = transaction.copy()
if 'passphrase' in tx:
tx.pop('passphrase')
gas = cf.estimateGas(tx)
transact_transaction['gas'] = gas
return transact_with_contract_function(
cf.address,
cf.web3,
cf.function_identifier,
transact_transaction,
cf.contract_abi,
cf.abi,
*cf.args,
**cf.kwargs
) | python | def transact(self, transaction=None):
"""
Customize calling smart contract transaction functions to use `personal_sendTransaction`
instead of `eth_sendTransaction` and to estimate gas limit. This function
is largely copied from web3 ContractFunction with important addition.
Note: will fallback to `eth_sendTransaction` if `passphrase` is not provided in the
`transaction` dict.
:param transaction: dict which has the required transaction arguments per
`personal_sendTransaction` requirements.
:return: hex str transaction hash
"""
if transaction is None:
transact_transaction = {}
else:
transact_transaction = dict(**transaction)
if 'data' in transact_transaction:
raise ValueError("Cannot set data in transact transaction")
cf = self._contract_function
if cf.address is not None:
transact_transaction.setdefault('to', cf.address)
if cf.web3.eth.defaultAccount is not empty:
transact_transaction.setdefault('from', cf.web3.eth.defaultAccount)
if 'to' not in transact_transaction:
if isinstance(self, type):
raise ValueError(
"When using `Contract.transact` from a contract factory you "
"must provide a `to` address with the transaction"
)
else:
raise ValueError(
"Please ensure that this contract instance has an address."
)
if 'gas' not in transact_transaction:
tx = transaction.copy()
if 'passphrase' in tx:
tx.pop('passphrase')
gas = cf.estimateGas(tx)
transact_transaction['gas'] = gas
return transact_with_contract_function(
cf.address,
cf.web3,
cf.function_identifier,
transact_transaction,
cf.contract_abi,
cf.abi,
*cf.args,
**cf.kwargs
) | [
"def",
"transact",
"(",
"self",
",",
"transaction",
"=",
"None",
")",
":",
"if",
"transaction",
"is",
"None",
":",
"transact_transaction",
"=",
"{",
"}",
"else",
":",
"transact_transaction",
"=",
"dict",
"(",
"*",
"*",
"transaction",
")",
"if",
"'data'",
"in",
"transact_transaction",
":",
"raise",
"ValueError",
"(",
"\"Cannot set data in transact transaction\"",
")",
"cf",
"=",
"self",
".",
"_contract_function",
"if",
"cf",
".",
"address",
"is",
"not",
"None",
":",
"transact_transaction",
".",
"setdefault",
"(",
"'to'",
",",
"cf",
".",
"address",
")",
"if",
"cf",
".",
"web3",
".",
"eth",
".",
"defaultAccount",
"is",
"not",
"empty",
":",
"transact_transaction",
".",
"setdefault",
"(",
"'from'",
",",
"cf",
".",
"web3",
".",
"eth",
".",
"defaultAccount",
")",
"if",
"'to'",
"not",
"in",
"transact_transaction",
":",
"if",
"isinstance",
"(",
"self",
",",
"type",
")",
":",
"raise",
"ValueError",
"(",
"\"When using `Contract.transact` from a contract factory you \"",
"\"must provide a `to` address with the transaction\"",
")",
"else",
":",
"raise",
"ValueError",
"(",
"\"Please ensure that this contract instance has an address.\"",
")",
"if",
"'gas'",
"not",
"in",
"transact_transaction",
":",
"tx",
"=",
"transaction",
".",
"copy",
"(",
")",
"if",
"'passphrase'",
"in",
"tx",
":",
"tx",
".",
"pop",
"(",
"'passphrase'",
")",
"gas",
"=",
"cf",
".",
"estimateGas",
"(",
"tx",
")",
"transact_transaction",
"[",
"'gas'",
"]",
"=",
"gas",
"return",
"transact_with_contract_function",
"(",
"cf",
".",
"address",
",",
"cf",
".",
"web3",
",",
"cf",
".",
"function_identifier",
",",
"transact_transaction",
",",
"cf",
".",
"contract_abi",
",",
"cf",
".",
"abi",
",",
"*",
"cf",
".",
"args",
",",
"*",
"*",
"cf",
".",
"kwargs",
")"
] | Customize calling smart contract transaction functions to use `personal_sendTransaction`
instead of `eth_sendTransaction` and to estimate gas limit. This function
is largely copied from web3 ContractFunction with important addition.
Note: will fallback to `eth_sendTransaction` if `passphrase` is not provided in the
`transaction` dict.
:param transaction: dict which has the required transaction arguments per
`personal_sendTransaction` requirements.
:return: hex str transaction hash | [
"Customize",
"calling",
"smart",
"contract",
"transaction",
"functions",
"to",
"use",
"personal_sendTransaction",
"instead",
"of",
"eth_sendTransaction",
"and",
"to",
"estimate",
"gas",
"limit",
".",
"This",
"function",
"is",
"largely",
"copied",
"from",
"web3",
"ContractFunction",
"with",
"important",
"addition",
"."
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/keeper/web3/contract.py#L10-L64 | train | 235,420 |
oceanprotocol/squid-py | squid_py/keeper/conditions/escrow_reward.py | EscrowRewardCondition.fulfill | def fulfill(self,
agreement_id,
amount,
receiver_address,
sender_address,
lock_condition_id,
release_condition_id,
account):
"""
Fulfill the escrow reward condition.
:param agreement_id: id of the agreement, hex str
:param amount: Amount of tokens, int
:param receiver_address: ethereum address of the receiver, hex str
:param sender_address: ethereum address of the sender, hex str
:param lock_condition_id: id of the condition, str
:param release_condition_id: id of the condition, str
:param account: Account instance
:return:
"""
return self._fulfill(
agreement_id,
amount,
receiver_address,
sender_address,
lock_condition_id,
release_condition_id,
transact={'from': account.address,
'passphrase': account.password}
) | python | def fulfill(self,
agreement_id,
amount,
receiver_address,
sender_address,
lock_condition_id,
release_condition_id,
account):
"""
Fulfill the escrow reward condition.
:param agreement_id: id of the agreement, hex str
:param amount: Amount of tokens, int
:param receiver_address: ethereum address of the receiver, hex str
:param sender_address: ethereum address of the sender, hex str
:param lock_condition_id: id of the condition, str
:param release_condition_id: id of the condition, str
:param account: Account instance
:return:
"""
return self._fulfill(
agreement_id,
amount,
receiver_address,
sender_address,
lock_condition_id,
release_condition_id,
transact={'from': account.address,
'passphrase': account.password}
) | [
"def",
"fulfill",
"(",
"self",
",",
"agreement_id",
",",
"amount",
",",
"receiver_address",
",",
"sender_address",
",",
"lock_condition_id",
",",
"release_condition_id",
",",
"account",
")",
":",
"return",
"self",
".",
"_fulfill",
"(",
"agreement_id",
",",
"amount",
",",
"receiver_address",
",",
"sender_address",
",",
"lock_condition_id",
",",
"release_condition_id",
",",
"transact",
"=",
"{",
"'from'",
":",
"account",
".",
"address",
",",
"'passphrase'",
":",
"account",
".",
"password",
"}",
")"
] | Fulfill the escrow reward condition.
:param agreement_id: id of the agreement, hex str
:param amount: Amount of tokens, int
:param receiver_address: ethereum address of the receiver, hex str
:param sender_address: ethereum address of the sender, hex str
:param lock_condition_id: id of the condition, str
:param release_condition_id: id of the condition, str
:param account: Account instance
:return: | [
"Fulfill",
"the",
"escrow",
"reward",
"condition",
"."
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/keeper/conditions/escrow_reward.py#L11-L40 | train | 235,421 |
oceanprotocol/squid-py | squid_py/keeper/conditions/escrow_reward.py | EscrowRewardCondition.hash_values | def hash_values(self, amount, receiver_address, sender_address, lock_condition_id,
release_condition_id):
"""
Hash the values of the escrow reward condition.
:param amount: Amount of tokens, int
:param receiver_address: ethereum address of the receiver, hex str
:param sender_address: ethereum address of the sender, hex str
:param lock_condition_id: id of the condition, str
:param release_condition_id: id of the condition, str
:return: hex str
"""
return self._hash_values(
amount,
receiver_address,
sender_address,
lock_condition_id,
release_condition_id
) | python | def hash_values(self, amount, receiver_address, sender_address, lock_condition_id,
release_condition_id):
"""
Hash the values of the escrow reward condition.
:param amount: Amount of tokens, int
:param receiver_address: ethereum address of the receiver, hex str
:param sender_address: ethereum address of the sender, hex str
:param lock_condition_id: id of the condition, str
:param release_condition_id: id of the condition, str
:return: hex str
"""
return self._hash_values(
amount,
receiver_address,
sender_address,
lock_condition_id,
release_condition_id
) | [
"def",
"hash_values",
"(",
"self",
",",
"amount",
",",
"receiver_address",
",",
"sender_address",
",",
"lock_condition_id",
",",
"release_condition_id",
")",
":",
"return",
"self",
".",
"_hash_values",
"(",
"amount",
",",
"receiver_address",
",",
"sender_address",
",",
"lock_condition_id",
",",
"release_condition_id",
")"
] | Hash the values of the escrow reward condition.
:param amount: Amount of tokens, int
:param receiver_address: ethereum address of the receiver, hex str
:param sender_address: ethereum address of the sender, hex str
:param lock_condition_id: id of the condition, str
:param release_condition_id: id of the condition, str
:return: hex str | [
"Hash",
"the",
"values",
"of",
"the",
"escrow",
"reward",
"condition",
"."
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/keeper/conditions/escrow_reward.py#L42-L60 | train | 235,422 |
oceanprotocol/squid-py | squid_py/agreements/service_agreement_condition.py | Parameter.as_dictionary | def as_dictionary(self):
"""
Return the parameter as a dictionary.
:return: dict
"""
return {
"name": self.name,
"type": self.type,
"value": remove_0x_prefix(self.value) if self.type == 'bytes32' else self.value
} | python | def as_dictionary(self):
"""
Return the parameter as a dictionary.
:return: dict
"""
return {
"name": self.name,
"type": self.type,
"value": remove_0x_prefix(self.value) if self.type == 'bytes32' else self.value
} | [
"def",
"as_dictionary",
"(",
"self",
")",
":",
"return",
"{",
"\"name\"",
":",
"self",
".",
"name",
",",
"\"type\"",
":",
"self",
".",
"type",
",",
"\"value\"",
":",
"remove_0x_prefix",
"(",
"self",
".",
"value",
")",
"if",
"self",
".",
"type",
"==",
"'bytes32'",
"else",
"self",
".",
"value",
"}"
] | Return the parameter as a dictionary.
:return: dict | [
"Return",
"the",
"parameter",
"as",
"a",
"dictionary",
"."
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/agreements/service_agreement_condition.py#L21-L31 | train | 235,423 |
oceanprotocol/squid-py | squid_py/agreements/service_agreement_condition.py | ServiceAgreementCondition.init_from_condition_json | def init_from_condition_json(self, condition_json):
"""
Init the condition values from a condition json.
:param condition_json: dict
"""
self.name = condition_json['name']
self.timelock = condition_json['timelock']
self.timeout = condition_json['timeout']
self.contract_name = condition_json['contractName']
self.function_name = condition_json['functionName']
self.parameters = [Parameter(p) for p in condition_json['parameters']]
self.events = [Event(e) for e in condition_json['events']] | python | def init_from_condition_json(self, condition_json):
"""
Init the condition values from a condition json.
:param condition_json: dict
"""
self.name = condition_json['name']
self.timelock = condition_json['timelock']
self.timeout = condition_json['timeout']
self.contract_name = condition_json['contractName']
self.function_name = condition_json['functionName']
self.parameters = [Parameter(p) for p in condition_json['parameters']]
self.events = [Event(e) for e in condition_json['events']] | [
"def",
"init_from_condition_json",
"(",
"self",
",",
"condition_json",
")",
":",
"self",
".",
"name",
"=",
"condition_json",
"[",
"'name'",
"]",
"self",
".",
"timelock",
"=",
"condition_json",
"[",
"'timelock'",
"]",
"self",
".",
"timeout",
"=",
"condition_json",
"[",
"'timeout'",
"]",
"self",
".",
"contract_name",
"=",
"condition_json",
"[",
"'contractName'",
"]",
"self",
".",
"function_name",
"=",
"condition_json",
"[",
"'functionName'",
"]",
"self",
".",
"parameters",
"=",
"[",
"Parameter",
"(",
"p",
")",
"for",
"p",
"in",
"condition_json",
"[",
"'parameters'",
"]",
"]",
"self",
".",
"events",
"=",
"[",
"Event",
"(",
"e",
")",
"for",
"e",
"in",
"condition_json",
"[",
"'events'",
"]",
"]"
] | Init the condition values from a condition json.
:param condition_json: dict | [
"Init",
"the",
"condition",
"values",
"from",
"a",
"condition",
"json",
"."
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/agreements/service_agreement_condition.py#L93-L105 | train | 235,424 |
oceanprotocol/squid-py | squid_py/agreements/service_agreement_condition.py | ServiceAgreementCondition.as_dictionary | def as_dictionary(self):
"""
Return the condition as a dictionary.
:return: dict
"""
condition_dict = {
"name": self.name,
"timelock": self.timelock,
"timeout": self.timeout,
"contractName": self.contract_name,
"functionName": self.function_name,
"events": [e.as_dictionary() for e in self.events],
"parameters": [p.as_dictionary() for p in self.parameters],
}
return condition_dict | python | def as_dictionary(self):
"""
Return the condition as a dictionary.
:return: dict
"""
condition_dict = {
"name": self.name,
"timelock": self.timelock,
"timeout": self.timeout,
"contractName": self.contract_name,
"functionName": self.function_name,
"events": [e.as_dictionary() for e in self.events],
"parameters": [p.as_dictionary() for p in self.parameters],
}
return condition_dict | [
"def",
"as_dictionary",
"(",
"self",
")",
":",
"condition_dict",
"=",
"{",
"\"name\"",
":",
"self",
".",
"name",
",",
"\"timelock\"",
":",
"self",
".",
"timelock",
",",
"\"timeout\"",
":",
"self",
".",
"timeout",
",",
"\"contractName\"",
":",
"self",
".",
"contract_name",
",",
"\"functionName\"",
":",
"self",
".",
"function_name",
",",
"\"events\"",
":",
"[",
"e",
".",
"as_dictionary",
"(",
")",
"for",
"e",
"in",
"self",
".",
"events",
"]",
",",
"\"parameters\"",
":",
"[",
"p",
".",
"as_dictionary",
"(",
")",
"for",
"p",
"in",
"self",
".",
"parameters",
"]",
",",
"}",
"return",
"condition_dict"
] | Return the condition as a dictionary.
:return: dict | [
"Return",
"the",
"condition",
"as",
"a",
"dictionary",
"."
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/agreements/service_agreement_condition.py#L107-L123 | train | 235,425 |
oceanprotocol/squid-py | squid_py/ddo/service.py | Service.update_value | def update_value(self, name, value):
"""
Update value in the array of values.
:param name: Key of the value, str
:param value: New value, str
:return: None
"""
if name not in {'id', self.SERVICE_ENDPOINT, self.CONSUME_ENDPOINT, 'type'}:
self._values[name] = value | python | def update_value(self, name, value):
"""
Update value in the array of values.
:param name: Key of the value, str
:param value: New value, str
:return: None
"""
if name not in {'id', self.SERVICE_ENDPOINT, self.CONSUME_ENDPOINT, 'type'}:
self._values[name] = value | [
"def",
"update_value",
"(",
"self",
",",
"name",
",",
"value",
")",
":",
"if",
"name",
"not",
"in",
"{",
"'id'",
",",
"self",
".",
"SERVICE_ENDPOINT",
",",
"self",
".",
"CONSUME_ENDPOINT",
",",
"'type'",
"}",
":",
"self",
".",
"_values",
"[",
"name",
"]",
"=",
"value"
] | Update value in the array of values.
:param name: Key of the value, str
:param value: New value, str
:return: None | [
"Update",
"value",
"in",
"the",
"array",
"of",
"values",
"."
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/ddo/service.py#L92-L101 | train | 235,426 |
oceanprotocol/squid-py | squid_py/ddo/service.py | Service.as_text | def as_text(self, is_pretty=False):
"""Return the service as a JSON string."""
values = {
'type': self._type,
self.SERVICE_ENDPOINT: self._service_endpoint,
}
if self._consume_endpoint is not None:
values[self.CONSUME_ENDPOINT] = self._consume_endpoint
if self._values:
# add extra service values to the dictionary
for name, value in self._values.items():
values[name] = value
if is_pretty:
return json.dumps(values, indent=4, separators=(',', ': '))
return json.dumps(values) | python | def as_text(self, is_pretty=False):
"""Return the service as a JSON string."""
values = {
'type': self._type,
self.SERVICE_ENDPOINT: self._service_endpoint,
}
if self._consume_endpoint is not None:
values[self.CONSUME_ENDPOINT] = self._consume_endpoint
if self._values:
# add extra service values to the dictionary
for name, value in self._values.items():
values[name] = value
if is_pretty:
return json.dumps(values, indent=4, separators=(',', ': '))
return json.dumps(values) | [
"def",
"as_text",
"(",
"self",
",",
"is_pretty",
"=",
"False",
")",
":",
"values",
"=",
"{",
"'type'",
":",
"self",
".",
"_type",
",",
"self",
".",
"SERVICE_ENDPOINT",
":",
"self",
".",
"_service_endpoint",
",",
"}",
"if",
"self",
".",
"_consume_endpoint",
"is",
"not",
"None",
":",
"values",
"[",
"self",
".",
"CONSUME_ENDPOINT",
"]",
"=",
"self",
".",
"_consume_endpoint",
"if",
"self",
".",
"_values",
":",
"# add extra service values to the dictionary",
"for",
"name",
",",
"value",
"in",
"self",
".",
"_values",
".",
"items",
"(",
")",
":",
"values",
"[",
"name",
"]",
"=",
"value",
"if",
"is_pretty",
":",
"return",
"json",
".",
"dumps",
"(",
"values",
",",
"indent",
"=",
"4",
",",
"separators",
"=",
"(",
"','",
",",
"': '",
")",
")",
"return",
"json",
".",
"dumps",
"(",
"values",
")"
] | Return the service as a JSON string. | [
"Return",
"the",
"service",
"as",
"a",
"JSON",
"string",
"."
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/ddo/service.py#L116-L132 | train | 235,427 |
oceanprotocol/squid-py | squid_py/ddo/service.py | Service.as_dictionary | def as_dictionary(self):
"""Return the service as a python dictionary."""
values = {
'type': self._type,
self.SERVICE_ENDPOINT: self._service_endpoint,
}
if self._consume_endpoint is not None:
values[self.CONSUME_ENDPOINT] = self._consume_endpoint
if self._values:
# add extra service values to the dictionary
for name, value in self._values.items():
if isinstance(value, object) and hasattr(value, 'as_dictionary'):
value = value.as_dictionary()
elif isinstance(value, list):
value = [v.as_dictionary() if hasattr(v, 'as_dictionary') else v for v in value]
values[name] = value
return values | python | def as_dictionary(self):
"""Return the service as a python dictionary."""
values = {
'type': self._type,
self.SERVICE_ENDPOINT: self._service_endpoint,
}
if self._consume_endpoint is not None:
values[self.CONSUME_ENDPOINT] = self._consume_endpoint
if self._values:
# add extra service values to the dictionary
for name, value in self._values.items():
if isinstance(value, object) and hasattr(value, 'as_dictionary'):
value = value.as_dictionary()
elif isinstance(value, list):
value = [v.as_dictionary() if hasattr(v, 'as_dictionary') else v for v in value]
values[name] = value
return values | [
"def",
"as_dictionary",
"(",
"self",
")",
":",
"values",
"=",
"{",
"'type'",
":",
"self",
".",
"_type",
",",
"self",
".",
"SERVICE_ENDPOINT",
":",
"self",
".",
"_service_endpoint",
",",
"}",
"if",
"self",
".",
"_consume_endpoint",
"is",
"not",
"None",
":",
"values",
"[",
"self",
".",
"CONSUME_ENDPOINT",
"]",
"=",
"self",
".",
"_consume_endpoint",
"if",
"self",
".",
"_values",
":",
"# add extra service values to the dictionary",
"for",
"name",
",",
"value",
"in",
"self",
".",
"_values",
".",
"items",
"(",
")",
":",
"if",
"isinstance",
"(",
"value",
",",
"object",
")",
"and",
"hasattr",
"(",
"value",
",",
"'as_dictionary'",
")",
":",
"value",
"=",
"value",
".",
"as_dictionary",
"(",
")",
"elif",
"isinstance",
"(",
"value",
",",
"list",
")",
":",
"value",
"=",
"[",
"v",
".",
"as_dictionary",
"(",
")",
"if",
"hasattr",
"(",
"v",
",",
"'as_dictionary'",
")",
"else",
"v",
"for",
"v",
"in",
"value",
"]",
"values",
"[",
"name",
"]",
"=",
"value",
"return",
"values"
] | Return the service as a python dictionary. | [
"Return",
"the",
"service",
"as",
"a",
"python",
"dictionary",
"."
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/ddo/service.py#L134-L151 | train | 235,428 |
oceanprotocol/squid-py | squid_py/ddo/service.py | Service.from_json | def from_json(cls, service_dict):
"""Create a service object from a JSON string."""
sd = service_dict.copy()
service_endpoint = sd.get(cls.SERVICE_ENDPOINT)
if not service_endpoint:
logger.error(
'Service definition in DDO document is missing the "serviceEndpoint" key/value.')
raise IndexError
_type = sd.get('type')
if not _type:
logger.error('Service definition in DDO document is missing the "type" key/value.')
raise IndexError
sd.pop(cls.SERVICE_ENDPOINT)
sd.pop('type')
return cls(
service_endpoint,
_type,
sd
) | python | def from_json(cls, service_dict):
"""Create a service object from a JSON string."""
sd = service_dict.copy()
service_endpoint = sd.get(cls.SERVICE_ENDPOINT)
if not service_endpoint:
logger.error(
'Service definition in DDO document is missing the "serviceEndpoint" key/value.')
raise IndexError
_type = sd.get('type')
if not _type:
logger.error('Service definition in DDO document is missing the "type" key/value.')
raise IndexError
sd.pop(cls.SERVICE_ENDPOINT)
sd.pop('type')
return cls(
service_endpoint,
_type,
sd
) | [
"def",
"from_json",
"(",
"cls",
",",
"service_dict",
")",
":",
"sd",
"=",
"service_dict",
".",
"copy",
"(",
")",
"service_endpoint",
"=",
"sd",
".",
"get",
"(",
"cls",
".",
"SERVICE_ENDPOINT",
")",
"if",
"not",
"service_endpoint",
":",
"logger",
".",
"error",
"(",
"'Service definition in DDO document is missing the \"serviceEndpoint\" key/value.'",
")",
"raise",
"IndexError",
"_type",
"=",
"sd",
".",
"get",
"(",
"'type'",
")",
"if",
"not",
"_type",
":",
"logger",
".",
"error",
"(",
"'Service definition in DDO document is missing the \"type\" key/value.'",
")",
"raise",
"IndexError",
"sd",
".",
"pop",
"(",
"cls",
".",
"SERVICE_ENDPOINT",
")",
"sd",
".",
"pop",
"(",
"'type'",
")",
"return",
"cls",
"(",
"service_endpoint",
",",
"_type",
",",
"sd",
")"
] | Create a service object from a JSON string. | [
"Create",
"a",
"service",
"object",
"from",
"a",
"JSON",
"string",
"."
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/ddo/service.py#L154-L174 | train | 235,429 |
oceanprotocol/squid-py | squid_py/keeper/conditions/access.py | AccessSecretStoreCondition.fulfill | def fulfill(self, agreement_id, document_id, grantee_address, account):
"""
Fulfill the access secret store condition.
:param agreement_id: id of the agreement, hex str
:param document_id: refers to the DID in which secret store will issue the decryption
keys, DID
:param grantee_address: is the address of the granted user, str
:param account: Account instance
:return: true if the condition was successfully fulfilled, bool
"""
return self._fulfill(
agreement_id,
document_id,
grantee_address,
transact={'from': account.address,
'passphrase': account.password}
) | python | def fulfill(self, agreement_id, document_id, grantee_address, account):
"""
Fulfill the access secret store condition.
:param agreement_id: id of the agreement, hex str
:param document_id: refers to the DID in which secret store will issue the decryption
keys, DID
:param grantee_address: is the address of the granted user, str
:param account: Account instance
:return: true if the condition was successfully fulfilled, bool
"""
return self._fulfill(
agreement_id,
document_id,
grantee_address,
transact={'from': account.address,
'passphrase': account.password}
) | [
"def",
"fulfill",
"(",
"self",
",",
"agreement_id",
",",
"document_id",
",",
"grantee_address",
",",
"account",
")",
":",
"return",
"self",
".",
"_fulfill",
"(",
"agreement_id",
",",
"document_id",
",",
"grantee_address",
",",
"transact",
"=",
"{",
"'from'",
":",
"account",
".",
"address",
",",
"'passphrase'",
":",
"account",
".",
"password",
"}",
")"
] | Fulfill the access secret store condition.
:param agreement_id: id of the agreement, hex str
:param document_id: refers to the DID in which secret store will issue the decryption
keys, DID
:param grantee_address: is the address of the granted user, str
:param account: Account instance
:return: true if the condition was successfully fulfilled, bool | [
"Fulfill",
"the",
"access",
"secret",
"store",
"condition",
"."
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/keeper/conditions/access.py#L13-L30 | train | 235,430 |
oceanprotocol/squid-py | squid_py/keeper/conditions/access.py | AccessSecretStoreCondition.get_purchased_assets_by_address | def get_purchased_assets_by_address(self, address, from_block=0, to_block='latest'):
"""
Get the list of the assets dids consumed for an address.
:param address: is the address of the granted user, hex-str
:param from_block: block to start to listen
:param to_block: block to stop to listen
:return: list of dids
"""
block_filter = EventFilter(
ConditionBase.FULFILLED_EVENT,
getattr(self.events, ConditionBase.FULFILLED_EVENT),
from_block=from_block,
to_block=to_block,
argument_filters={'_grantee': address}
)
log_items = block_filter.get_all_entries(max_tries=5)
did_list = []
for log_i in log_items:
did_list.append(id_to_did(log_i.args['_documentId']))
return did_list | python | def get_purchased_assets_by_address(self, address, from_block=0, to_block='latest'):
"""
Get the list of the assets dids consumed for an address.
:param address: is the address of the granted user, hex-str
:param from_block: block to start to listen
:param to_block: block to stop to listen
:return: list of dids
"""
block_filter = EventFilter(
ConditionBase.FULFILLED_EVENT,
getattr(self.events, ConditionBase.FULFILLED_EVENT),
from_block=from_block,
to_block=to_block,
argument_filters={'_grantee': address}
)
log_items = block_filter.get_all_entries(max_tries=5)
did_list = []
for log_i in log_items:
did_list.append(id_to_did(log_i.args['_documentId']))
return did_list | [
"def",
"get_purchased_assets_by_address",
"(",
"self",
",",
"address",
",",
"from_block",
"=",
"0",
",",
"to_block",
"=",
"'latest'",
")",
":",
"block_filter",
"=",
"EventFilter",
"(",
"ConditionBase",
".",
"FULFILLED_EVENT",
",",
"getattr",
"(",
"self",
".",
"events",
",",
"ConditionBase",
".",
"FULFILLED_EVENT",
")",
",",
"from_block",
"=",
"from_block",
",",
"to_block",
"=",
"to_block",
",",
"argument_filters",
"=",
"{",
"'_grantee'",
":",
"address",
"}",
")",
"log_items",
"=",
"block_filter",
".",
"get_all_entries",
"(",
"max_tries",
"=",
"5",
")",
"did_list",
"=",
"[",
"]",
"for",
"log_i",
"in",
"log_items",
":",
"did_list",
".",
"append",
"(",
"id_to_did",
"(",
"log_i",
".",
"args",
"[",
"'_documentId'",
"]",
")",
")",
"return",
"did_list"
] | Get the list of the assets dids consumed for an address.
:param address: is the address of the granted user, hex-str
:param from_block: block to start to listen
:param to_block: block to stop to listen
:return: list of dids | [
"Get",
"the",
"list",
"of",
"the",
"assets",
"dids",
"consumed",
"for",
"an",
"address",
"."
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/keeper/conditions/access.py#L55-L76 | train | 235,431 |
oceanprotocol/squid-py | squid_py/keeper/web3_provider.py | Web3Provider.get_web3 | def get_web3():
"""Return the web3 instance to interact with the ethereum client."""
if Web3Provider._web3 is None:
config = ConfigProvider.get_config()
provider = (
config.web3_provider
if config.web3_provider
else CustomHTTPProvider(
config.keeper_url
)
)
Web3Provider._web3 = Web3(provider)
# Reset attributes to avoid lint issue about no attribute
Web3Provider._web3.eth = getattr(Web3Provider._web3, 'eth')
Web3Provider._web3.net = getattr(Web3Provider._web3, 'net')
Web3Provider._web3.personal = getattr(Web3Provider._web3, 'personal')
Web3Provider._web3.version = getattr(Web3Provider._web3, 'version')
Web3Provider._web3.txpool = getattr(Web3Provider._web3, 'txpool')
Web3Provider._web3.miner = getattr(Web3Provider._web3, 'miner')
Web3Provider._web3.admin = getattr(Web3Provider._web3, 'admin')
Web3Provider._web3.parity = getattr(Web3Provider._web3, 'parity')
Web3Provider._web3.testing = getattr(Web3Provider._web3, 'testing')
return Web3Provider._web3 | python | def get_web3():
"""Return the web3 instance to interact with the ethereum client."""
if Web3Provider._web3 is None:
config = ConfigProvider.get_config()
provider = (
config.web3_provider
if config.web3_provider
else CustomHTTPProvider(
config.keeper_url
)
)
Web3Provider._web3 = Web3(provider)
# Reset attributes to avoid lint issue about no attribute
Web3Provider._web3.eth = getattr(Web3Provider._web3, 'eth')
Web3Provider._web3.net = getattr(Web3Provider._web3, 'net')
Web3Provider._web3.personal = getattr(Web3Provider._web3, 'personal')
Web3Provider._web3.version = getattr(Web3Provider._web3, 'version')
Web3Provider._web3.txpool = getattr(Web3Provider._web3, 'txpool')
Web3Provider._web3.miner = getattr(Web3Provider._web3, 'miner')
Web3Provider._web3.admin = getattr(Web3Provider._web3, 'admin')
Web3Provider._web3.parity = getattr(Web3Provider._web3, 'parity')
Web3Provider._web3.testing = getattr(Web3Provider._web3, 'testing')
return Web3Provider._web3 | [
"def",
"get_web3",
"(",
")",
":",
"if",
"Web3Provider",
".",
"_web3",
"is",
"None",
":",
"config",
"=",
"ConfigProvider",
".",
"get_config",
"(",
")",
"provider",
"=",
"(",
"config",
".",
"web3_provider",
"if",
"config",
".",
"web3_provider",
"else",
"CustomHTTPProvider",
"(",
"config",
".",
"keeper_url",
")",
")",
"Web3Provider",
".",
"_web3",
"=",
"Web3",
"(",
"provider",
")",
"# Reset attributes to avoid lint issue about no attribute",
"Web3Provider",
".",
"_web3",
".",
"eth",
"=",
"getattr",
"(",
"Web3Provider",
".",
"_web3",
",",
"'eth'",
")",
"Web3Provider",
".",
"_web3",
".",
"net",
"=",
"getattr",
"(",
"Web3Provider",
".",
"_web3",
",",
"'net'",
")",
"Web3Provider",
".",
"_web3",
".",
"personal",
"=",
"getattr",
"(",
"Web3Provider",
".",
"_web3",
",",
"'personal'",
")",
"Web3Provider",
".",
"_web3",
".",
"version",
"=",
"getattr",
"(",
"Web3Provider",
".",
"_web3",
",",
"'version'",
")",
"Web3Provider",
".",
"_web3",
".",
"txpool",
"=",
"getattr",
"(",
"Web3Provider",
".",
"_web3",
",",
"'txpool'",
")",
"Web3Provider",
".",
"_web3",
".",
"miner",
"=",
"getattr",
"(",
"Web3Provider",
".",
"_web3",
",",
"'miner'",
")",
"Web3Provider",
".",
"_web3",
".",
"admin",
"=",
"getattr",
"(",
"Web3Provider",
".",
"_web3",
",",
"'admin'",
")",
"Web3Provider",
".",
"_web3",
".",
"parity",
"=",
"getattr",
"(",
"Web3Provider",
".",
"_web3",
",",
"'parity'",
")",
"Web3Provider",
".",
"_web3",
".",
"testing",
"=",
"getattr",
"(",
"Web3Provider",
".",
"_web3",
",",
"'testing'",
")",
"return",
"Web3Provider",
".",
"_web3"
] | Return the web3 instance to interact with the ethereum client. | [
"Return",
"the",
"web3",
"instance",
"to",
"interact",
"with",
"the",
"ethereum",
"client",
"."
] | 43a5b7431627e4c9ab7382ed9eb8153e96ed4483 | https://github.com/oceanprotocol/squid-py/blob/43a5b7431627e4c9ab7382ed9eb8153e96ed4483/squid_py/keeper/web3_provider.py#L15-L38 | train | 235,432 |
BlueBrain/NeuroM | neurom/core/_soma.py | _get_type | def _get_type(points, soma_class):
'''get the type of the soma
Args:
points: Soma points
soma_class(str): one of 'contour' or 'cylinder' to specify the type
'''
assert soma_class in (SOMA_CONTOUR, SOMA_CYLINDER)
npoints = len(points)
if soma_class == SOMA_CONTOUR:
return {0: None,
1: SomaSinglePoint,
2: None}.get(npoints, SomaSimpleContour)
if(npoints == 3 and
points[0][COLS.P] == -1 and
points[1][COLS.P] == 1 and
points[2][COLS.P] == 1):
L.warning('Using neuromorpho 3-Point soma')
# NeuroMorpho is the main provider of morphologies, but they
# with SWC as their default file format: they convert all
# uploads to SWC. In the process of conversion, they turn all
# somas into their custom 'Three-point soma representation':
# http://neuromorpho.org/SomaFormat.html
return SomaNeuromorphoThreePointCylinders
return {0: None,
1: SomaSinglePoint}.get(npoints, SomaCylinders) | python | def _get_type(points, soma_class):
'''get the type of the soma
Args:
points: Soma points
soma_class(str): one of 'contour' or 'cylinder' to specify the type
'''
assert soma_class in (SOMA_CONTOUR, SOMA_CYLINDER)
npoints = len(points)
if soma_class == SOMA_CONTOUR:
return {0: None,
1: SomaSinglePoint,
2: None}.get(npoints, SomaSimpleContour)
if(npoints == 3 and
points[0][COLS.P] == -1 and
points[1][COLS.P] == 1 and
points[2][COLS.P] == 1):
L.warning('Using neuromorpho 3-Point soma')
# NeuroMorpho is the main provider of morphologies, but they
# with SWC as their default file format: they convert all
# uploads to SWC. In the process of conversion, they turn all
# somas into their custom 'Three-point soma representation':
# http://neuromorpho.org/SomaFormat.html
return SomaNeuromorphoThreePointCylinders
return {0: None,
1: SomaSinglePoint}.get(npoints, SomaCylinders) | [
"def",
"_get_type",
"(",
"points",
",",
"soma_class",
")",
":",
"assert",
"soma_class",
"in",
"(",
"SOMA_CONTOUR",
",",
"SOMA_CYLINDER",
")",
"npoints",
"=",
"len",
"(",
"points",
")",
"if",
"soma_class",
"==",
"SOMA_CONTOUR",
":",
"return",
"{",
"0",
":",
"None",
",",
"1",
":",
"SomaSinglePoint",
",",
"2",
":",
"None",
"}",
".",
"get",
"(",
"npoints",
",",
"SomaSimpleContour",
")",
"if",
"(",
"npoints",
"==",
"3",
"and",
"points",
"[",
"0",
"]",
"[",
"COLS",
".",
"P",
"]",
"==",
"-",
"1",
"and",
"points",
"[",
"1",
"]",
"[",
"COLS",
".",
"P",
"]",
"==",
"1",
"and",
"points",
"[",
"2",
"]",
"[",
"COLS",
".",
"P",
"]",
"==",
"1",
")",
":",
"L",
".",
"warning",
"(",
"'Using neuromorpho 3-Point soma'",
")",
"# NeuroMorpho is the main provider of morphologies, but they",
"# with SWC as their default file format: they convert all",
"# uploads to SWC. In the process of conversion, they turn all",
"# somas into their custom 'Three-point soma representation':",
"# http://neuromorpho.org/SomaFormat.html",
"return",
"SomaNeuromorphoThreePointCylinders",
"return",
"{",
"0",
":",
"None",
",",
"1",
":",
"SomaSinglePoint",
"}",
".",
"get",
"(",
"npoints",
",",
"SomaCylinders",
")"
] | get the type of the soma
Args:
points: Soma points
soma_class(str): one of 'contour' or 'cylinder' to specify the type | [
"get",
"the",
"type",
"of",
"the",
"soma"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/core/_soma.py#L203-L232 | train | 235,433 |
BlueBrain/NeuroM | neurom/core/_soma.py | make_soma | def make_soma(points, soma_check=None, soma_class=SOMA_CONTOUR):
'''Make a soma object from a set of points
Infers the soma type (SomaSinglePoint, SomaSimpleContour)
from the points and the 'soma_class'
Parameters:
points: collection of points forming a soma.
soma_check: optional validation function applied to points. Should
raise a SomaError if points not valid.
soma_class(str): one of 'contour' or 'cylinder' to specify the type
Raises:
SomaError if no soma points found, points incompatible with soma, or
if soma_check(points) fails.
'''
if soma_check:
soma_check(points)
stype = _get_type(points, soma_class)
if stype is None:
raise SomaError('Invalid soma points')
return stype(points) | python | def make_soma(points, soma_check=None, soma_class=SOMA_CONTOUR):
'''Make a soma object from a set of points
Infers the soma type (SomaSinglePoint, SomaSimpleContour)
from the points and the 'soma_class'
Parameters:
points: collection of points forming a soma.
soma_check: optional validation function applied to points. Should
raise a SomaError if points not valid.
soma_class(str): one of 'contour' or 'cylinder' to specify the type
Raises:
SomaError if no soma points found, points incompatible with soma, or
if soma_check(points) fails.
'''
if soma_check:
soma_check(points)
stype = _get_type(points, soma_class)
if stype is None:
raise SomaError('Invalid soma points')
return stype(points) | [
"def",
"make_soma",
"(",
"points",
",",
"soma_check",
"=",
"None",
",",
"soma_class",
"=",
"SOMA_CONTOUR",
")",
":",
"if",
"soma_check",
":",
"soma_check",
"(",
"points",
")",
"stype",
"=",
"_get_type",
"(",
"points",
",",
"soma_class",
")",
"if",
"stype",
"is",
"None",
":",
"raise",
"SomaError",
"(",
"'Invalid soma points'",
")",
"return",
"stype",
"(",
"points",
")"
] | Make a soma object from a set of points
Infers the soma type (SomaSinglePoint, SomaSimpleContour)
from the points and the 'soma_class'
Parameters:
points: collection of points forming a soma.
soma_check: optional validation function applied to points. Should
raise a SomaError if points not valid.
soma_class(str): one of 'contour' or 'cylinder' to specify the type
Raises:
SomaError if no soma points found, points incompatible with soma, or
if soma_check(points) fails. | [
"Make",
"a",
"soma",
"object",
"from",
"a",
"set",
"of",
"points"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/core/_soma.py#L235-L260 | train | 235,434 |
BlueBrain/NeuroM | neurom/core/_soma.py | SomaSimpleContour.center | def center(self):
'''Obtain the center from the average of all points'''
points = np.array(self._points)
return np.mean(points[:, COLS.XYZ], axis=0) | python | def center(self):
'''Obtain the center from the average of all points'''
points = np.array(self._points)
return np.mean(points[:, COLS.XYZ], axis=0) | [
"def",
"center",
"(",
"self",
")",
":",
"points",
"=",
"np",
".",
"array",
"(",
"self",
".",
"_points",
")",
"return",
"np",
".",
"mean",
"(",
"points",
"[",
":",
",",
"COLS",
".",
"XYZ",
"]",
",",
"axis",
"=",
"0",
")"
] | Obtain the center from the average of all points | [
"Obtain",
"the",
"center",
"from",
"the",
"average",
"of",
"all",
"points"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/core/_soma.py#L188-L191 | train | 235,435 |
BlueBrain/NeuroM | neurom/fst/sectionfunc.py | section_tortuosity | def section_tortuosity(section):
'''Tortuosity of a section
The tortuosity is defined as the ratio of the path length of a section
and the euclidian distnce between its end points.
The path length is the sum of distances between consecutive points.
If the section contains less than 2 points, the value 1 is returned.
'''
pts = section.points
return 1 if len(pts) < 2 else mm.section_length(pts) / mm.point_dist(pts[-1], pts[0]) | python | def section_tortuosity(section):
'''Tortuosity of a section
The tortuosity is defined as the ratio of the path length of a section
and the euclidian distnce between its end points.
The path length is the sum of distances between consecutive points.
If the section contains less than 2 points, the value 1 is returned.
'''
pts = section.points
return 1 if len(pts) < 2 else mm.section_length(pts) / mm.point_dist(pts[-1], pts[0]) | [
"def",
"section_tortuosity",
"(",
"section",
")",
":",
"pts",
"=",
"section",
".",
"points",
"return",
"1",
"if",
"len",
"(",
"pts",
")",
"<",
"2",
"else",
"mm",
".",
"section_length",
"(",
"pts",
")",
"/",
"mm",
".",
"point_dist",
"(",
"pts",
"[",
"-",
"1",
"]",
",",
"pts",
"[",
"0",
"]",
")"
] | Tortuosity of a section
The tortuosity is defined as the ratio of the path length of a section
and the euclidian distnce between its end points.
The path length is the sum of distances between consecutive points.
If the section contains less than 2 points, the value 1 is returned. | [
"Tortuosity",
"of",
"a",
"section"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/fst/sectionfunc.py#L50-L61 | train | 235,436 |
BlueBrain/NeuroM | neurom/fst/sectionfunc.py | section_end_distance | def section_end_distance(section):
'''End to end distance of a section
The end to end distance of a section is defined as
the euclidian distnce between its end points.
If the section contains less than 2 points, the value 0 is returned.
'''
pts = section.points
return 0 if len(pts) < 2 else mm.point_dist(pts[-1], pts[0]) | python | def section_end_distance(section):
'''End to end distance of a section
The end to end distance of a section is defined as
the euclidian distnce between its end points.
If the section contains less than 2 points, the value 0 is returned.
'''
pts = section.points
return 0 if len(pts) < 2 else mm.point_dist(pts[-1], pts[0]) | [
"def",
"section_end_distance",
"(",
"section",
")",
":",
"pts",
"=",
"section",
".",
"points",
"return",
"0",
"if",
"len",
"(",
"pts",
")",
"<",
"2",
"else",
"mm",
".",
"point_dist",
"(",
"pts",
"[",
"-",
"1",
"]",
",",
"pts",
"[",
"0",
"]",
")"
] | End to end distance of a section
The end to end distance of a section is defined as
the euclidian distnce between its end points.
If the section contains less than 2 points, the value 0 is returned. | [
"End",
"to",
"end",
"distance",
"of",
"a",
"section"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/fst/sectionfunc.py#L64-L73 | train | 235,437 |
BlueBrain/NeuroM | neurom/fst/sectionfunc.py | strahler_order | def strahler_order(section):
'''Branching order of a tree section
The strahler order is the inverse of the branch order,
since this is computed from the tips of the tree
towards the root.
This implementation is a translation of the three steps described in
Wikipedia (https://en.wikipedia.org/wiki/Strahler_number):
- If the node is a leaf (has no children), its Strahler number is one.
- If the node has one child with Strahler number i, and all other children
have Strahler numbers less than i, then the Strahler number of the node
is i again.
- If the node has two or more children with Strahler number i, and no
children with greater number, then the Strahler number of the node is
i + 1.
No efforts have been invested in making it computationnaly efficient, but
it computes acceptably fast on tested morphologies (i.e., no waiting time).
'''
if section.children:
child_orders = [strahler_order(child) for child in section.children]
max_so_children = max(child_orders)
it = iter(co == max_so_children for co in child_orders)
# check if there are *two* or more children w/ the max_so_children
any(it)
if any(it):
return max_so_children + 1
return max_so_children
return 1 | python | def strahler_order(section):
'''Branching order of a tree section
The strahler order is the inverse of the branch order,
since this is computed from the tips of the tree
towards the root.
This implementation is a translation of the three steps described in
Wikipedia (https://en.wikipedia.org/wiki/Strahler_number):
- If the node is a leaf (has no children), its Strahler number is one.
- If the node has one child with Strahler number i, and all other children
have Strahler numbers less than i, then the Strahler number of the node
is i again.
- If the node has two or more children with Strahler number i, and no
children with greater number, then the Strahler number of the node is
i + 1.
No efforts have been invested in making it computationnaly efficient, but
it computes acceptably fast on tested morphologies (i.e., no waiting time).
'''
if section.children:
child_orders = [strahler_order(child) for child in section.children]
max_so_children = max(child_orders)
it = iter(co == max_so_children for co in child_orders)
# check if there are *two* or more children w/ the max_so_children
any(it)
if any(it):
return max_so_children + 1
return max_so_children
return 1 | [
"def",
"strahler_order",
"(",
"section",
")",
":",
"if",
"section",
".",
"children",
":",
"child_orders",
"=",
"[",
"strahler_order",
"(",
"child",
")",
"for",
"child",
"in",
"section",
".",
"children",
"]",
"max_so_children",
"=",
"max",
"(",
"child_orders",
")",
"it",
"=",
"iter",
"(",
"co",
"==",
"max_so_children",
"for",
"co",
"in",
"child_orders",
")",
"# check if there are *two* or more children w/ the max_so_children",
"any",
"(",
"it",
")",
"if",
"any",
"(",
"it",
")",
":",
"return",
"max_so_children",
"+",
"1",
"return",
"max_so_children",
"return",
"1"
] | Branching order of a tree section
The strahler order is the inverse of the branch order,
since this is computed from the tips of the tree
towards the root.
This implementation is a translation of the three steps described in
Wikipedia (https://en.wikipedia.org/wiki/Strahler_number):
- If the node is a leaf (has no children), its Strahler number is one.
- If the node has one child with Strahler number i, and all other children
have Strahler numbers less than i, then the Strahler number of the node
is i again.
- If the node has two or more children with Strahler number i, and no
children with greater number, then the Strahler number of the node is
i + 1.
No efforts have been invested in making it computationnaly efficient, but
it computes acceptably fast on tested morphologies (i.e., no waiting time). | [
"Branching",
"order",
"of",
"a",
"tree",
"section"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/fst/sectionfunc.py#L108-L138 | train | 235,438 |
BlueBrain/NeuroM | neurom/view/common.py | figure_naming | def figure_naming(pretitle='', posttitle='', prefile='', postfile=''):
"""
Helper function to define the strings that handle pre-post conventions
for viewing - plotting title and saving options.
Args:
pretitle(str): String to include before the general title of the figure.
posttitle(str): String to include after the general title of the figure.
prefile(str): String to include before the general filename of the figure.
postfile(str): String to include after the general filename of the figure.
Returns:
str: String to include in the figure name and title, in a suitable form.
"""
if pretitle:
pretitle = "%s -- " % pretitle
if posttitle:
posttitle = " -- %s" % posttitle
if prefile:
prefile = "%s_" % prefile
if postfile:
postfile = "_%s" % postfile
return pretitle, posttitle, prefile, postfile | python | def figure_naming(pretitle='', posttitle='', prefile='', postfile=''):
"""
Helper function to define the strings that handle pre-post conventions
for viewing - plotting title and saving options.
Args:
pretitle(str): String to include before the general title of the figure.
posttitle(str): String to include after the general title of the figure.
prefile(str): String to include before the general filename of the figure.
postfile(str): String to include after the general filename of the figure.
Returns:
str: String to include in the figure name and title, in a suitable form.
"""
if pretitle:
pretitle = "%s -- " % pretitle
if posttitle:
posttitle = " -- %s" % posttitle
if prefile:
prefile = "%s_" % prefile
if postfile:
postfile = "_%s" % postfile
return pretitle, posttitle, prefile, postfile | [
"def",
"figure_naming",
"(",
"pretitle",
"=",
"''",
",",
"posttitle",
"=",
"''",
",",
"prefile",
"=",
"''",
",",
"postfile",
"=",
"''",
")",
":",
"if",
"pretitle",
":",
"pretitle",
"=",
"\"%s -- \"",
"%",
"pretitle",
"if",
"posttitle",
":",
"posttitle",
"=",
"\" -- %s\"",
"%",
"posttitle",
"if",
"prefile",
":",
"prefile",
"=",
"\"%s_\"",
"%",
"prefile",
"if",
"postfile",
":",
"postfile",
"=",
"\"_%s\"",
"%",
"postfile",
"return",
"pretitle",
",",
"posttitle",
",",
"prefile",
",",
"postfile"
] | Helper function to define the strings that handle pre-post conventions
for viewing - plotting title and saving options.
Args:
pretitle(str): String to include before the general title of the figure.
posttitle(str): String to include after the general title of the figure.
prefile(str): String to include before the general filename of the figure.
postfile(str): String to include after the general filename of the figure.
Returns:
str: String to include in the figure name and title, in a suitable form. | [
"Helper",
"function",
"to",
"define",
"the",
"strings",
"that",
"handle",
"pre",
"-",
"post",
"conventions",
"for",
"viewing",
"-",
"plotting",
"title",
"and",
"saving",
"options",
"."
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/view/common.py#L56-L82 | train | 235,439 |
BlueBrain/NeuroM | neurom/view/common.py | get_figure | def get_figure(new_fig=True, subplot='111', params=None):
"""
Function to be used for viewing - plotting,
to initialize the matplotlib figure - axes.
Args:
new_fig(bool): Defines if a new figure will be created, if false current figure is used
subplot (tuple or matplolib subplot specifier string): Create axes with these parameters
params (dict): extra options passed to add_subplot()
Returns:
Matplotlib Figure and Axes
"""
_get_plt()
if new_fig:
fig = plt.figure()
else:
fig = plt.gcf()
params = dict_if_none(params)
if isinstance(subplot, (tuple, list)):
ax = fig.add_subplot(*subplot, **params)
else:
ax = fig.add_subplot(subplot, **params)
return fig, ax | python | def get_figure(new_fig=True, subplot='111', params=None):
"""
Function to be used for viewing - plotting,
to initialize the matplotlib figure - axes.
Args:
new_fig(bool): Defines if a new figure will be created, if false current figure is used
subplot (tuple or matplolib subplot specifier string): Create axes with these parameters
params (dict): extra options passed to add_subplot()
Returns:
Matplotlib Figure and Axes
"""
_get_plt()
if new_fig:
fig = plt.figure()
else:
fig = plt.gcf()
params = dict_if_none(params)
if isinstance(subplot, (tuple, list)):
ax = fig.add_subplot(*subplot, **params)
else:
ax = fig.add_subplot(subplot, **params)
return fig, ax | [
"def",
"get_figure",
"(",
"new_fig",
"=",
"True",
",",
"subplot",
"=",
"'111'",
",",
"params",
"=",
"None",
")",
":",
"_get_plt",
"(",
")",
"if",
"new_fig",
":",
"fig",
"=",
"plt",
".",
"figure",
"(",
")",
"else",
":",
"fig",
"=",
"plt",
".",
"gcf",
"(",
")",
"params",
"=",
"dict_if_none",
"(",
"params",
")",
"if",
"isinstance",
"(",
"subplot",
",",
"(",
"tuple",
",",
"list",
")",
")",
":",
"ax",
"=",
"fig",
".",
"add_subplot",
"(",
"*",
"subplot",
",",
"*",
"*",
"params",
")",
"else",
":",
"ax",
"=",
"fig",
".",
"add_subplot",
"(",
"subplot",
",",
"*",
"*",
"params",
")",
"return",
"fig",
",",
"ax"
] | Function to be used for viewing - plotting,
to initialize the matplotlib figure - axes.
Args:
new_fig(bool): Defines if a new figure will be created, if false current figure is used
subplot (tuple or matplolib subplot specifier string): Create axes with these parameters
params (dict): extra options passed to add_subplot()
Returns:
Matplotlib Figure and Axes | [
"Function",
"to",
"be",
"used",
"for",
"viewing",
"-",
"plotting",
"to",
"initialize",
"the",
"matplotlib",
"figure",
"-",
"axes",
"."
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/view/common.py#L85-L112 | train | 235,440 |
BlueBrain/NeuroM | neurom/view/common.py | save_plot | def save_plot(fig, prefile='', postfile='', output_path='./', output_name='Figure',
output_format='png', dpi=300, transparent=False, **_):
"""Generates a figure file in the selected directory.
Args:
fig: matplotlib figure
prefile(str): Include before the general filename of the figure
postfile(str): Included after the general filename of the figure
output_path(str): Define the path to the output directory
output_name(str): String to define the name of the output figure
output_format(str): String to define the format of the output figure
dpi(int): Define the DPI (Dots per Inch) of the figure
transparent(bool): If True the saved figure will have a transparent background
"""
if not os.path.exists(output_path):
os.makedirs(output_path) # Make output directory if non-exsiting
output = os.path.join(output_path,
prefile + output_name + postfile + "." + output_format)
fig.savefig(output, dpi=dpi, transparent=transparent) | python | def save_plot(fig, prefile='', postfile='', output_path='./', output_name='Figure',
output_format='png', dpi=300, transparent=False, **_):
"""Generates a figure file in the selected directory.
Args:
fig: matplotlib figure
prefile(str): Include before the general filename of the figure
postfile(str): Included after the general filename of the figure
output_path(str): Define the path to the output directory
output_name(str): String to define the name of the output figure
output_format(str): String to define the format of the output figure
dpi(int): Define the DPI (Dots per Inch) of the figure
transparent(bool): If True the saved figure will have a transparent background
"""
if not os.path.exists(output_path):
os.makedirs(output_path) # Make output directory if non-exsiting
output = os.path.join(output_path,
prefile + output_name + postfile + "." + output_format)
fig.savefig(output, dpi=dpi, transparent=transparent) | [
"def",
"save_plot",
"(",
"fig",
",",
"prefile",
"=",
"''",
",",
"postfile",
"=",
"''",
",",
"output_path",
"=",
"'./'",
",",
"output_name",
"=",
"'Figure'",
",",
"output_format",
"=",
"'png'",
",",
"dpi",
"=",
"300",
",",
"transparent",
"=",
"False",
",",
"*",
"*",
"_",
")",
":",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"output_path",
")",
":",
"os",
".",
"makedirs",
"(",
"output_path",
")",
"# Make output directory if non-exsiting",
"output",
"=",
"os",
".",
"path",
".",
"join",
"(",
"output_path",
",",
"prefile",
"+",
"output_name",
"+",
"postfile",
"+",
"\".\"",
"+",
"output_format",
")",
"fig",
".",
"savefig",
"(",
"output",
",",
"dpi",
"=",
"dpi",
",",
"transparent",
"=",
"transparent",
")"
] | Generates a figure file in the selected directory.
Args:
fig: matplotlib figure
prefile(str): Include before the general filename of the figure
postfile(str): Included after the general filename of the figure
output_path(str): Define the path to the output directory
output_name(str): String to define the name of the output figure
output_format(str): String to define the format of the output figure
dpi(int): Define the DPI (Dots per Inch) of the figure
transparent(bool): If True the saved figure will have a transparent background | [
"Generates",
"a",
"figure",
"file",
"in",
"the",
"selected",
"directory",
"."
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/view/common.py#L115-L135 | train | 235,441 |
BlueBrain/NeuroM | neurom/view/common.py | plot_style | def plot_style(fig, ax, # pylint: disable=too-many-arguments, too-many-locals
# plot_title
pretitle='',
title='Figure',
posttitle='',
title_fontsize=14,
title_arg=None,
# plot_labels
label_fontsize=14,
xlabel=None,
xlabel_arg=None,
ylabel=None,
ylabel_arg=None,
zlabel=None,
zlabel_arg=None,
# plot_ticks
tick_fontsize=12,
xticks=None,
xticks_args=None,
yticks=None,
yticks_args=None,
zticks=None,
zticks_args=None,
# update_plot_limits
white_space=30,
# plot_legend
no_legend=True,
legend_arg=None,
# internal
no_axes=False,
aspect_ratio='equal',
tight=False,
**_):
"""Set the basic options of a matplotlib figure, to be used by viewing - plotting functions
Args:
fig(matplotlib figure): figure
ax(matplotlib axes, belonging to `fig`): axes
pretitle(str): String to include before the general title of the figure
posttitle (str): String to include after the general title of the figure
title (str): Set the title for the figure
title_fontsize (int): Defines the size of the title's font
title_arg (dict): Addition arguments for matplotlib.title() call
label_fontsize(int): Size of the labels' font
xlabel(str): The xlabel for the figure
xlabel_arg(dict): Passsed into matplotlib as xlabel arguments
ylabel(str): The ylabel for the figure
ylabel_arg(dict): Passsed into matplotlib as ylabel arguments
zlabel(str): The zlabel for the figure
zlabel_arg(dict): Passsed into matplotlib as zlabel arguments
tick_fontsize (int): Defines the size of the ticks' font
xticks([list of ticks]): Defines the values of x ticks in the figure
xticks_args(dict): Passsed into matplotlib as xticks arguments
yticks([list of ticks]): Defines the values of y ticks in the figure
yticks_args(dict): Passsed into matplotlib as yticks arguments
zticks([list of ticks]): Defines the values of z ticks in the figure
zticks_args(dict): Passsed into matplotlib as zticks arguments
white_space(float): whitespace added to surround the tight limit of the data
no_legend (bool): Defines the presence of a legend in the figure
legend_arg (dict): Addition arguments for matplotlib.legend() call
no_axes(bool): If True the labels and the frame will be set off
aspect_ratio(str): Sets aspect ratio of the figure, according to matplotlib aspect_ratio
tight(bool): If True the tight layout of matplotlib will be activated
Returns:
Matplotlib figure, matplotlib axes
"""
plot_title(ax, pretitle, title, posttitle, title_fontsize, title_arg)
plot_labels(ax, label_fontsize, xlabel, xlabel_arg, ylabel, ylabel_arg, zlabel, zlabel_arg)
plot_ticks(ax, tick_fontsize, xticks, xticks_args, yticks, yticks_args, zticks, zticks_args)
update_plot_limits(ax, white_space)
plot_legend(ax, no_legend, legend_arg)
if no_axes:
ax.set_frame_on(False)
ax.xaxis.set_visible(False)
ax.yaxis.set_visible(False)
ax.set_aspect(aspect_ratio)
if tight:
fig.set_tight_layout(True) | python | def plot_style(fig, ax, # pylint: disable=too-many-arguments, too-many-locals
# plot_title
pretitle='',
title='Figure',
posttitle='',
title_fontsize=14,
title_arg=None,
# plot_labels
label_fontsize=14,
xlabel=None,
xlabel_arg=None,
ylabel=None,
ylabel_arg=None,
zlabel=None,
zlabel_arg=None,
# plot_ticks
tick_fontsize=12,
xticks=None,
xticks_args=None,
yticks=None,
yticks_args=None,
zticks=None,
zticks_args=None,
# update_plot_limits
white_space=30,
# plot_legend
no_legend=True,
legend_arg=None,
# internal
no_axes=False,
aspect_ratio='equal',
tight=False,
**_):
"""Set the basic options of a matplotlib figure, to be used by viewing - plotting functions
Args:
fig(matplotlib figure): figure
ax(matplotlib axes, belonging to `fig`): axes
pretitle(str): String to include before the general title of the figure
posttitle (str): String to include after the general title of the figure
title (str): Set the title for the figure
title_fontsize (int): Defines the size of the title's font
title_arg (dict): Addition arguments for matplotlib.title() call
label_fontsize(int): Size of the labels' font
xlabel(str): The xlabel for the figure
xlabel_arg(dict): Passsed into matplotlib as xlabel arguments
ylabel(str): The ylabel for the figure
ylabel_arg(dict): Passsed into matplotlib as ylabel arguments
zlabel(str): The zlabel for the figure
zlabel_arg(dict): Passsed into matplotlib as zlabel arguments
tick_fontsize (int): Defines the size of the ticks' font
xticks([list of ticks]): Defines the values of x ticks in the figure
xticks_args(dict): Passsed into matplotlib as xticks arguments
yticks([list of ticks]): Defines the values of y ticks in the figure
yticks_args(dict): Passsed into matplotlib as yticks arguments
zticks([list of ticks]): Defines the values of z ticks in the figure
zticks_args(dict): Passsed into matplotlib as zticks arguments
white_space(float): whitespace added to surround the tight limit of the data
no_legend (bool): Defines the presence of a legend in the figure
legend_arg (dict): Addition arguments for matplotlib.legend() call
no_axes(bool): If True the labels and the frame will be set off
aspect_ratio(str): Sets aspect ratio of the figure, according to matplotlib aspect_ratio
tight(bool): If True the tight layout of matplotlib will be activated
Returns:
Matplotlib figure, matplotlib axes
"""
plot_title(ax, pretitle, title, posttitle, title_fontsize, title_arg)
plot_labels(ax, label_fontsize, xlabel, xlabel_arg, ylabel, ylabel_arg, zlabel, zlabel_arg)
plot_ticks(ax, tick_fontsize, xticks, xticks_args, yticks, yticks_args, zticks, zticks_args)
update_plot_limits(ax, white_space)
plot_legend(ax, no_legend, legend_arg)
if no_axes:
ax.set_frame_on(False)
ax.xaxis.set_visible(False)
ax.yaxis.set_visible(False)
ax.set_aspect(aspect_ratio)
if tight:
fig.set_tight_layout(True) | [
"def",
"plot_style",
"(",
"fig",
",",
"ax",
",",
"# pylint: disable=too-many-arguments, too-many-locals",
"# plot_title",
"pretitle",
"=",
"''",
",",
"title",
"=",
"'Figure'",
",",
"posttitle",
"=",
"''",
",",
"title_fontsize",
"=",
"14",
",",
"title_arg",
"=",
"None",
",",
"# plot_labels",
"label_fontsize",
"=",
"14",
",",
"xlabel",
"=",
"None",
",",
"xlabel_arg",
"=",
"None",
",",
"ylabel",
"=",
"None",
",",
"ylabel_arg",
"=",
"None",
",",
"zlabel",
"=",
"None",
",",
"zlabel_arg",
"=",
"None",
",",
"# plot_ticks",
"tick_fontsize",
"=",
"12",
",",
"xticks",
"=",
"None",
",",
"xticks_args",
"=",
"None",
",",
"yticks",
"=",
"None",
",",
"yticks_args",
"=",
"None",
",",
"zticks",
"=",
"None",
",",
"zticks_args",
"=",
"None",
",",
"# update_plot_limits",
"white_space",
"=",
"30",
",",
"# plot_legend",
"no_legend",
"=",
"True",
",",
"legend_arg",
"=",
"None",
",",
"# internal",
"no_axes",
"=",
"False",
",",
"aspect_ratio",
"=",
"'equal'",
",",
"tight",
"=",
"False",
",",
"*",
"*",
"_",
")",
":",
"plot_title",
"(",
"ax",
",",
"pretitle",
",",
"title",
",",
"posttitle",
",",
"title_fontsize",
",",
"title_arg",
")",
"plot_labels",
"(",
"ax",
",",
"label_fontsize",
",",
"xlabel",
",",
"xlabel_arg",
",",
"ylabel",
",",
"ylabel_arg",
",",
"zlabel",
",",
"zlabel_arg",
")",
"plot_ticks",
"(",
"ax",
",",
"tick_fontsize",
",",
"xticks",
",",
"xticks_args",
",",
"yticks",
",",
"yticks_args",
",",
"zticks",
",",
"zticks_args",
")",
"update_plot_limits",
"(",
"ax",
",",
"white_space",
")",
"plot_legend",
"(",
"ax",
",",
"no_legend",
",",
"legend_arg",
")",
"if",
"no_axes",
":",
"ax",
".",
"set_frame_on",
"(",
"False",
")",
"ax",
".",
"xaxis",
".",
"set_visible",
"(",
"False",
")",
"ax",
".",
"yaxis",
".",
"set_visible",
"(",
"False",
")",
"ax",
".",
"set_aspect",
"(",
"aspect_ratio",
")",
"if",
"tight",
":",
"fig",
".",
"set_tight_layout",
"(",
"True",
")"
] | Set the basic options of a matplotlib figure, to be used by viewing - plotting functions
Args:
fig(matplotlib figure): figure
ax(matplotlib axes, belonging to `fig`): axes
pretitle(str): String to include before the general title of the figure
posttitle (str): String to include after the general title of the figure
title (str): Set the title for the figure
title_fontsize (int): Defines the size of the title's font
title_arg (dict): Addition arguments for matplotlib.title() call
label_fontsize(int): Size of the labels' font
xlabel(str): The xlabel for the figure
xlabel_arg(dict): Passsed into matplotlib as xlabel arguments
ylabel(str): The ylabel for the figure
ylabel_arg(dict): Passsed into matplotlib as ylabel arguments
zlabel(str): The zlabel for the figure
zlabel_arg(dict): Passsed into matplotlib as zlabel arguments
tick_fontsize (int): Defines the size of the ticks' font
xticks([list of ticks]): Defines the values of x ticks in the figure
xticks_args(dict): Passsed into matplotlib as xticks arguments
yticks([list of ticks]): Defines the values of y ticks in the figure
yticks_args(dict): Passsed into matplotlib as yticks arguments
zticks([list of ticks]): Defines the values of z ticks in the figure
zticks_args(dict): Passsed into matplotlib as zticks arguments
white_space(float): whitespace added to surround the tight limit of the data
no_legend (bool): Defines the presence of a legend in the figure
legend_arg (dict): Addition arguments for matplotlib.legend() call
no_axes(bool): If True the labels and the frame will be set off
aspect_ratio(str): Sets aspect ratio of the figure, according to matplotlib aspect_ratio
tight(bool): If True the tight layout of matplotlib will be activated
Returns:
Matplotlib figure, matplotlib axes | [
"Set",
"the",
"basic",
"options",
"of",
"a",
"matplotlib",
"figure",
"to",
"be",
"used",
"by",
"viewing",
"-",
"plotting",
"functions"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/view/common.py#L138-L225 | train | 235,442 |
BlueBrain/NeuroM | neurom/view/common.py | plot_title | def plot_title(ax, pretitle='', title='Figure', posttitle='', title_fontsize=14, title_arg=None):
"""Set title options of a matplotlib plot
Args:
ax: matplotlib axes
pretitle(str): String to include before the general title of the figure
posttitle (str): String to include after the general title of the figure
title (str): Set the title for the figure
title_fontsize (int): Defines the size of the title's font
title_arg (dict): Addition arguments for matplotlib.title() call
"""
current_title = ax.get_title()
if not current_title:
current_title = pretitle + title + posttitle
title_arg = dict_if_none(title_arg)
ax.set_title(current_title, fontsize=title_fontsize, **title_arg) | python | def plot_title(ax, pretitle='', title='Figure', posttitle='', title_fontsize=14, title_arg=None):
"""Set title options of a matplotlib plot
Args:
ax: matplotlib axes
pretitle(str): String to include before the general title of the figure
posttitle (str): String to include after the general title of the figure
title (str): Set the title for the figure
title_fontsize (int): Defines the size of the title's font
title_arg (dict): Addition arguments for matplotlib.title() call
"""
current_title = ax.get_title()
if not current_title:
current_title = pretitle + title + posttitle
title_arg = dict_if_none(title_arg)
ax.set_title(current_title, fontsize=title_fontsize, **title_arg) | [
"def",
"plot_title",
"(",
"ax",
",",
"pretitle",
"=",
"''",
",",
"title",
"=",
"'Figure'",
",",
"posttitle",
"=",
"''",
",",
"title_fontsize",
"=",
"14",
",",
"title_arg",
"=",
"None",
")",
":",
"current_title",
"=",
"ax",
".",
"get_title",
"(",
")",
"if",
"not",
"current_title",
":",
"current_title",
"=",
"pretitle",
"+",
"title",
"+",
"posttitle",
"title_arg",
"=",
"dict_if_none",
"(",
"title_arg",
")",
"ax",
".",
"set_title",
"(",
"current_title",
",",
"fontsize",
"=",
"title_fontsize",
",",
"*",
"*",
"title_arg",
")"
] | Set title options of a matplotlib plot
Args:
ax: matplotlib axes
pretitle(str): String to include before the general title of the figure
posttitle (str): String to include after the general title of the figure
title (str): Set the title for the figure
title_fontsize (int): Defines the size of the title's font
title_arg (dict): Addition arguments for matplotlib.title() call | [
"Set",
"title",
"options",
"of",
"a",
"matplotlib",
"plot"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/view/common.py#L228-L246 | train | 235,443 |
BlueBrain/NeuroM | neurom/view/common.py | plot_labels | def plot_labels(ax, label_fontsize=14,
xlabel=None, xlabel_arg=None,
ylabel=None, ylabel_arg=None,
zlabel=None, zlabel_arg=None):
"""Sets the labels options of a matplotlib plot
Args:
ax: matplotlib axes
label_fontsize(int): Size of the labels' font
xlabel(str): The xlabel for the figure
xlabel_arg(dict): Passsed into matplotlib as xlabel arguments
ylabel(str): The ylabel for the figure
ylabel_arg(dict): Passsed into matplotlib as ylabel arguments
zlabel(str): The zlabel for the figure
zlabel_arg(dict): Passsed into matplotlib as zlabel arguments
"""
xlabel = xlabel if xlabel is not None else ax.get_xlabel() or 'X'
ylabel = ylabel if ylabel is not None else ax.get_ylabel() or 'Y'
xlabel_arg = dict_if_none(xlabel_arg)
ylabel_arg = dict_if_none(ylabel_arg)
ax.set_xlabel(xlabel, fontsize=label_fontsize, **xlabel_arg)
ax.set_ylabel(ylabel, fontsize=label_fontsize, **ylabel_arg)
if hasattr(ax, 'zaxis'):
zlabel = zlabel if zlabel is not None else ax.get_zlabel() or 'Z'
zlabel_arg = dict_if_none(zlabel_arg)
ax.set_zlabel(zlabel, fontsize=label_fontsize, **zlabel_arg) | python | def plot_labels(ax, label_fontsize=14,
xlabel=None, xlabel_arg=None,
ylabel=None, ylabel_arg=None,
zlabel=None, zlabel_arg=None):
"""Sets the labels options of a matplotlib plot
Args:
ax: matplotlib axes
label_fontsize(int): Size of the labels' font
xlabel(str): The xlabel for the figure
xlabel_arg(dict): Passsed into matplotlib as xlabel arguments
ylabel(str): The ylabel for the figure
ylabel_arg(dict): Passsed into matplotlib as ylabel arguments
zlabel(str): The zlabel for the figure
zlabel_arg(dict): Passsed into matplotlib as zlabel arguments
"""
xlabel = xlabel if xlabel is not None else ax.get_xlabel() or 'X'
ylabel = ylabel if ylabel is not None else ax.get_ylabel() or 'Y'
xlabel_arg = dict_if_none(xlabel_arg)
ylabel_arg = dict_if_none(ylabel_arg)
ax.set_xlabel(xlabel, fontsize=label_fontsize, **xlabel_arg)
ax.set_ylabel(ylabel, fontsize=label_fontsize, **ylabel_arg)
if hasattr(ax, 'zaxis'):
zlabel = zlabel if zlabel is not None else ax.get_zlabel() or 'Z'
zlabel_arg = dict_if_none(zlabel_arg)
ax.set_zlabel(zlabel, fontsize=label_fontsize, **zlabel_arg) | [
"def",
"plot_labels",
"(",
"ax",
",",
"label_fontsize",
"=",
"14",
",",
"xlabel",
"=",
"None",
",",
"xlabel_arg",
"=",
"None",
",",
"ylabel",
"=",
"None",
",",
"ylabel_arg",
"=",
"None",
",",
"zlabel",
"=",
"None",
",",
"zlabel_arg",
"=",
"None",
")",
":",
"xlabel",
"=",
"xlabel",
"if",
"xlabel",
"is",
"not",
"None",
"else",
"ax",
".",
"get_xlabel",
"(",
")",
"or",
"'X'",
"ylabel",
"=",
"ylabel",
"if",
"ylabel",
"is",
"not",
"None",
"else",
"ax",
".",
"get_ylabel",
"(",
")",
"or",
"'Y'",
"xlabel_arg",
"=",
"dict_if_none",
"(",
"xlabel_arg",
")",
"ylabel_arg",
"=",
"dict_if_none",
"(",
"ylabel_arg",
")",
"ax",
".",
"set_xlabel",
"(",
"xlabel",
",",
"fontsize",
"=",
"label_fontsize",
",",
"*",
"*",
"xlabel_arg",
")",
"ax",
".",
"set_ylabel",
"(",
"ylabel",
",",
"fontsize",
"=",
"label_fontsize",
",",
"*",
"*",
"ylabel_arg",
")",
"if",
"hasattr",
"(",
"ax",
",",
"'zaxis'",
")",
":",
"zlabel",
"=",
"zlabel",
"if",
"zlabel",
"is",
"not",
"None",
"else",
"ax",
".",
"get_zlabel",
"(",
")",
"or",
"'Z'",
"zlabel_arg",
"=",
"dict_if_none",
"(",
"zlabel_arg",
")",
"ax",
".",
"set_zlabel",
"(",
"zlabel",
",",
"fontsize",
"=",
"label_fontsize",
",",
"*",
"*",
"zlabel_arg",
")"
] | Sets the labels options of a matplotlib plot
Args:
ax: matplotlib axes
label_fontsize(int): Size of the labels' font
xlabel(str): The xlabel for the figure
xlabel_arg(dict): Passsed into matplotlib as xlabel arguments
ylabel(str): The ylabel for the figure
ylabel_arg(dict): Passsed into matplotlib as ylabel arguments
zlabel(str): The zlabel for the figure
zlabel_arg(dict): Passsed into matplotlib as zlabel arguments | [
"Sets",
"the",
"labels",
"options",
"of",
"a",
"matplotlib",
"plot"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/view/common.py#L249-L277 | train | 235,444 |
BlueBrain/NeuroM | neurom/view/common.py | plot_ticks | def plot_ticks(ax, tick_fontsize=12,
xticks=None, xticks_args=None,
yticks=None, yticks_args=None,
zticks=None, zticks_args=None):
"""Function that defines the labels options of a matplotlib plot.
Args:
ax: matplotlib axes
tick_fontsize (int): Defines the size of the ticks' font
xticks([list of ticks]): Defines the values of x ticks in the figure
xticks_arg(dict): Passsed into matplotlib as xticks arguments
yticks([list of ticks]): Defines the values of y ticks in the figure
yticks_arg(dict): Passsed into matplotlib as yticks arguments
zticks([list of ticks]): Defines the values of z ticks in the figure
zticks_arg(dict): Passsed into matplotlib as zticks arguments
"""
if xticks is not None:
ax.set_xticks(xticks)
xticks_args = dict_if_none(xticks_args)
ax.xaxis.set_tick_params(labelsize=tick_fontsize, **xticks_args)
if yticks is not None:
ax.set_yticks(yticks)
yticks_args = dict_if_none(yticks_args)
ax.yaxis.set_tick_params(labelsize=tick_fontsize, **yticks_args)
if zticks is not None:
ax.set_zticks(zticks)
zticks_args = dict_if_none(zticks_args)
ax.zaxis.set_tick_params(labelsize=tick_fontsize, **zticks_args) | python | def plot_ticks(ax, tick_fontsize=12,
xticks=None, xticks_args=None,
yticks=None, yticks_args=None,
zticks=None, zticks_args=None):
"""Function that defines the labels options of a matplotlib plot.
Args:
ax: matplotlib axes
tick_fontsize (int): Defines the size of the ticks' font
xticks([list of ticks]): Defines the values of x ticks in the figure
xticks_arg(dict): Passsed into matplotlib as xticks arguments
yticks([list of ticks]): Defines the values of y ticks in the figure
yticks_arg(dict): Passsed into matplotlib as yticks arguments
zticks([list of ticks]): Defines the values of z ticks in the figure
zticks_arg(dict): Passsed into matplotlib as zticks arguments
"""
if xticks is not None:
ax.set_xticks(xticks)
xticks_args = dict_if_none(xticks_args)
ax.xaxis.set_tick_params(labelsize=tick_fontsize, **xticks_args)
if yticks is not None:
ax.set_yticks(yticks)
yticks_args = dict_if_none(yticks_args)
ax.yaxis.set_tick_params(labelsize=tick_fontsize, **yticks_args)
if zticks is not None:
ax.set_zticks(zticks)
zticks_args = dict_if_none(zticks_args)
ax.zaxis.set_tick_params(labelsize=tick_fontsize, **zticks_args) | [
"def",
"plot_ticks",
"(",
"ax",
",",
"tick_fontsize",
"=",
"12",
",",
"xticks",
"=",
"None",
",",
"xticks_args",
"=",
"None",
",",
"yticks",
"=",
"None",
",",
"yticks_args",
"=",
"None",
",",
"zticks",
"=",
"None",
",",
"zticks_args",
"=",
"None",
")",
":",
"if",
"xticks",
"is",
"not",
"None",
":",
"ax",
".",
"set_xticks",
"(",
"xticks",
")",
"xticks_args",
"=",
"dict_if_none",
"(",
"xticks_args",
")",
"ax",
".",
"xaxis",
".",
"set_tick_params",
"(",
"labelsize",
"=",
"tick_fontsize",
",",
"*",
"*",
"xticks_args",
")",
"if",
"yticks",
"is",
"not",
"None",
":",
"ax",
".",
"set_yticks",
"(",
"yticks",
")",
"yticks_args",
"=",
"dict_if_none",
"(",
"yticks_args",
")",
"ax",
".",
"yaxis",
".",
"set_tick_params",
"(",
"labelsize",
"=",
"tick_fontsize",
",",
"*",
"*",
"yticks_args",
")",
"if",
"zticks",
"is",
"not",
"None",
":",
"ax",
".",
"set_zticks",
"(",
"zticks",
")",
"zticks_args",
"=",
"dict_if_none",
"(",
"zticks_args",
")",
"ax",
".",
"zaxis",
".",
"set_tick_params",
"(",
"labelsize",
"=",
"tick_fontsize",
",",
"*",
"*",
"zticks_args",
")"
] | Function that defines the labels options of a matplotlib plot.
Args:
ax: matplotlib axes
tick_fontsize (int): Defines the size of the ticks' font
xticks([list of ticks]): Defines the values of x ticks in the figure
xticks_arg(dict): Passsed into matplotlib as xticks arguments
yticks([list of ticks]): Defines the values of y ticks in the figure
yticks_arg(dict): Passsed into matplotlib as yticks arguments
zticks([list of ticks]): Defines the values of z ticks in the figure
zticks_arg(dict): Passsed into matplotlib as zticks arguments | [
"Function",
"that",
"defines",
"the",
"labels",
"options",
"of",
"a",
"matplotlib",
"plot",
"."
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/view/common.py#L280-L309 | train | 235,445 |
BlueBrain/NeuroM | neurom/view/common.py | update_plot_limits | def update_plot_limits(ax, white_space):
"""Sets the limit options of a matplotlib plot.
Args:
ax: matplotlib axes
white_space(float): whitespace added to surround the tight limit of the data
Note: This relies on ax.dataLim (in 2d) and ax.[xy, zz]_dataLim being set in 3d
"""
if hasattr(ax, 'zz_dataLim'):
bounds = ax.xy_dataLim.bounds
ax.set_xlim(bounds[0] - white_space, bounds[0] + bounds[2] + white_space)
ax.set_ylim(bounds[1] - white_space, bounds[1] + bounds[3] + white_space)
bounds = ax.zz_dataLim.bounds
ax.set_zlim(bounds[0] - white_space, bounds[0] + bounds[2] + white_space)
else:
bounds = ax.dataLim.bounds
assert not any(map(np.isinf, bounds)), 'Cannot set bounds if dataLim has infinite elements'
ax.set_xlim(bounds[0] - white_space, bounds[0] + bounds[2] + white_space)
ax.set_ylim(bounds[1] - white_space, bounds[1] + bounds[3] + white_space) | python | def update_plot_limits(ax, white_space):
"""Sets the limit options of a matplotlib plot.
Args:
ax: matplotlib axes
white_space(float): whitespace added to surround the tight limit of the data
Note: This relies on ax.dataLim (in 2d) and ax.[xy, zz]_dataLim being set in 3d
"""
if hasattr(ax, 'zz_dataLim'):
bounds = ax.xy_dataLim.bounds
ax.set_xlim(bounds[0] - white_space, bounds[0] + bounds[2] + white_space)
ax.set_ylim(bounds[1] - white_space, bounds[1] + bounds[3] + white_space)
bounds = ax.zz_dataLim.bounds
ax.set_zlim(bounds[0] - white_space, bounds[0] + bounds[2] + white_space)
else:
bounds = ax.dataLim.bounds
assert not any(map(np.isinf, bounds)), 'Cannot set bounds if dataLim has infinite elements'
ax.set_xlim(bounds[0] - white_space, bounds[0] + bounds[2] + white_space)
ax.set_ylim(bounds[1] - white_space, bounds[1] + bounds[3] + white_space) | [
"def",
"update_plot_limits",
"(",
"ax",
",",
"white_space",
")",
":",
"if",
"hasattr",
"(",
"ax",
",",
"'zz_dataLim'",
")",
":",
"bounds",
"=",
"ax",
".",
"xy_dataLim",
".",
"bounds",
"ax",
".",
"set_xlim",
"(",
"bounds",
"[",
"0",
"]",
"-",
"white_space",
",",
"bounds",
"[",
"0",
"]",
"+",
"bounds",
"[",
"2",
"]",
"+",
"white_space",
")",
"ax",
".",
"set_ylim",
"(",
"bounds",
"[",
"1",
"]",
"-",
"white_space",
",",
"bounds",
"[",
"1",
"]",
"+",
"bounds",
"[",
"3",
"]",
"+",
"white_space",
")",
"bounds",
"=",
"ax",
".",
"zz_dataLim",
".",
"bounds",
"ax",
".",
"set_zlim",
"(",
"bounds",
"[",
"0",
"]",
"-",
"white_space",
",",
"bounds",
"[",
"0",
"]",
"+",
"bounds",
"[",
"2",
"]",
"+",
"white_space",
")",
"else",
":",
"bounds",
"=",
"ax",
".",
"dataLim",
".",
"bounds",
"assert",
"not",
"any",
"(",
"map",
"(",
"np",
".",
"isinf",
",",
"bounds",
")",
")",
",",
"'Cannot set bounds if dataLim has infinite elements'",
"ax",
".",
"set_xlim",
"(",
"bounds",
"[",
"0",
"]",
"-",
"white_space",
",",
"bounds",
"[",
"0",
"]",
"+",
"bounds",
"[",
"2",
"]",
"+",
"white_space",
")",
"ax",
".",
"set_ylim",
"(",
"bounds",
"[",
"1",
"]",
"-",
"white_space",
",",
"bounds",
"[",
"1",
"]",
"+",
"bounds",
"[",
"3",
"]",
"+",
"white_space",
")"
] | Sets the limit options of a matplotlib plot.
Args:
ax: matplotlib axes
white_space(float): whitespace added to surround the tight limit of the data
Note: This relies on ax.dataLim (in 2d) and ax.[xy, zz]_dataLim being set in 3d | [
"Sets",
"the",
"limit",
"options",
"of",
"a",
"matplotlib",
"plot",
"."
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/view/common.py#L312-L333 | train | 235,446 |
BlueBrain/NeuroM | neurom/view/common.py | plot_legend | def plot_legend(ax, no_legend=True, legend_arg=None):
"""
Function that defines the legend options
of a matplotlib plot.
Args:
ax: matplotlib axes
no_legend (bool): Defines the presence of a legend in the figure
legend_arg (dict): Addition arguments for matplotlib.legend() call
"""
legend_arg = dict_if_none(legend_arg)
if not no_legend:
ax.legend(**legend_arg) | python | def plot_legend(ax, no_legend=True, legend_arg=None):
"""
Function that defines the legend options
of a matplotlib plot.
Args:
ax: matplotlib axes
no_legend (bool): Defines the presence of a legend in the figure
legend_arg (dict): Addition arguments for matplotlib.legend() call
"""
legend_arg = dict_if_none(legend_arg)
if not no_legend:
ax.legend(**legend_arg) | [
"def",
"plot_legend",
"(",
"ax",
",",
"no_legend",
"=",
"True",
",",
"legend_arg",
"=",
"None",
")",
":",
"legend_arg",
"=",
"dict_if_none",
"(",
"legend_arg",
")",
"if",
"not",
"no_legend",
":",
"ax",
".",
"legend",
"(",
"*",
"*",
"legend_arg",
")"
] | Function that defines the legend options
of a matplotlib plot.
Args:
ax: matplotlib axes
no_legend (bool): Defines the presence of a legend in the figure
legend_arg (dict): Addition arguments for matplotlib.legend() call | [
"Function",
"that",
"defines",
"the",
"legend",
"options",
"of",
"a",
"matplotlib",
"plot",
"."
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/view/common.py#L336-L349 | train | 235,447 |
BlueBrain/NeuroM | neurom/view/common.py | generate_cylindrical_points | def generate_cylindrical_points(start, end, start_radius, end_radius,
linspace_count=_LINSPACE_COUNT):
'''Generate a 3d mesh of a cylinder with start and end points, and varying radius
Based on: http://stackoverflow.com/a/32383775
'''
v = end - start
length = norm(v)
v = v / length
n1, n2 = _get_normals(v)
# pylint: disable=unbalanced-tuple-unpacking
l, theta = np.meshgrid(np.linspace(0, length, linspace_count),
np.linspace(0, 2 * np.pi, linspace_count))
radii = np.linspace(start_radius, end_radius, linspace_count)
rsin = np.multiply(radii, np.sin(theta))
rcos = np.multiply(radii, np.cos(theta))
return np.array([start[i] +
v[i] * l +
n1[i] * rsin + n2[i] * rcos
for i in range(3)]) | python | def generate_cylindrical_points(start, end, start_radius, end_radius,
linspace_count=_LINSPACE_COUNT):
'''Generate a 3d mesh of a cylinder with start and end points, and varying radius
Based on: http://stackoverflow.com/a/32383775
'''
v = end - start
length = norm(v)
v = v / length
n1, n2 = _get_normals(v)
# pylint: disable=unbalanced-tuple-unpacking
l, theta = np.meshgrid(np.linspace(0, length, linspace_count),
np.linspace(0, 2 * np.pi, linspace_count))
radii = np.linspace(start_radius, end_radius, linspace_count)
rsin = np.multiply(radii, np.sin(theta))
rcos = np.multiply(radii, np.cos(theta))
return np.array([start[i] +
v[i] * l +
n1[i] * rsin + n2[i] * rcos
for i in range(3)]) | [
"def",
"generate_cylindrical_points",
"(",
"start",
",",
"end",
",",
"start_radius",
",",
"end_radius",
",",
"linspace_count",
"=",
"_LINSPACE_COUNT",
")",
":",
"v",
"=",
"end",
"-",
"start",
"length",
"=",
"norm",
"(",
"v",
")",
"v",
"=",
"v",
"/",
"length",
"n1",
",",
"n2",
"=",
"_get_normals",
"(",
"v",
")",
"# pylint: disable=unbalanced-tuple-unpacking",
"l",
",",
"theta",
"=",
"np",
".",
"meshgrid",
"(",
"np",
".",
"linspace",
"(",
"0",
",",
"length",
",",
"linspace_count",
")",
",",
"np",
".",
"linspace",
"(",
"0",
",",
"2",
"*",
"np",
".",
"pi",
",",
"linspace_count",
")",
")",
"radii",
"=",
"np",
".",
"linspace",
"(",
"start_radius",
",",
"end_radius",
",",
"linspace_count",
")",
"rsin",
"=",
"np",
".",
"multiply",
"(",
"radii",
",",
"np",
".",
"sin",
"(",
"theta",
")",
")",
"rcos",
"=",
"np",
".",
"multiply",
"(",
"radii",
",",
"np",
".",
"cos",
"(",
"theta",
")",
")",
"return",
"np",
".",
"array",
"(",
"[",
"start",
"[",
"i",
"]",
"+",
"v",
"[",
"i",
"]",
"*",
"l",
"+",
"n1",
"[",
"i",
"]",
"*",
"rsin",
"+",
"n2",
"[",
"i",
"]",
"*",
"rcos",
"for",
"i",
"in",
"range",
"(",
"3",
")",
"]",
")"
] | Generate a 3d mesh of a cylinder with start and end points, and varying radius
Based on: http://stackoverflow.com/a/32383775 | [
"Generate",
"a",
"3d",
"mesh",
"of",
"a",
"cylinder",
"with",
"start",
"and",
"end",
"points",
"and",
"varying",
"radius"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/view/common.py#L369-L391 | train | 235,448 |
BlueBrain/NeuroM | neurom/view/common.py | plot_cylinder | def plot_cylinder(ax, start, end, start_radius, end_radius,
color='black', alpha=1., linspace_count=_LINSPACE_COUNT):
'''plot a 3d cylinder'''
assert not np.all(start == end), 'Cylinder must have length'
x, y, z = generate_cylindrical_points(start, end, start_radius, end_radius,
linspace_count=linspace_count)
ax.plot_surface(x, y, z, color=color, alpha=alpha) | python | def plot_cylinder(ax, start, end, start_radius, end_radius,
color='black', alpha=1., linspace_count=_LINSPACE_COUNT):
'''plot a 3d cylinder'''
assert not np.all(start == end), 'Cylinder must have length'
x, y, z = generate_cylindrical_points(start, end, start_radius, end_radius,
linspace_count=linspace_count)
ax.plot_surface(x, y, z, color=color, alpha=alpha) | [
"def",
"plot_cylinder",
"(",
"ax",
",",
"start",
",",
"end",
",",
"start_radius",
",",
"end_radius",
",",
"color",
"=",
"'black'",
",",
"alpha",
"=",
"1.",
",",
"linspace_count",
"=",
"_LINSPACE_COUNT",
")",
":",
"assert",
"not",
"np",
".",
"all",
"(",
"start",
"==",
"end",
")",
",",
"'Cylinder must have length'",
"x",
",",
"y",
",",
"z",
"=",
"generate_cylindrical_points",
"(",
"start",
",",
"end",
",",
"start_radius",
",",
"end_radius",
",",
"linspace_count",
"=",
"linspace_count",
")",
"ax",
".",
"plot_surface",
"(",
"x",
",",
"y",
",",
"z",
",",
"color",
"=",
"color",
",",
"alpha",
"=",
"alpha",
")"
] | plot a 3d cylinder | [
"plot",
"a",
"3d",
"cylinder"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/view/common.py#L421-L427 | train | 235,449 |
BlueBrain/NeuroM | neurom/view/common.py | plot_sphere | def plot_sphere(ax, center, radius, color='black', alpha=1., linspace_count=_LINSPACE_COUNT):
""" Plots a 3d sphere, given the center and the radius. """
u = np.linspace(0, 2 * np.pi, linspace_count)
v = np.linspace(0, np.pi, linspace_count)
sin_v = np.sin(v)
x = center[0] + radius * np.outer(np.cos(u), sin_v)
y = center[1] + radius * np.outer(np.sin(u), sin_v)
z = center[2] + radius * np.outer(np.ones_like(u), np.cos(v))
ax.plot_surface(x, y, z, linewidth=0.0, color=color, alpha=alpha) | python | def plot_sphere(ax, center, radius, color='black', alpha=1., linspace_count=_LINSPACE_COUNT):
""" Plots a 3d sphere, given the center and the radius. """
u = np.linspace(0, 2 * np.pi, linspace_count)
v = np.linspace(0, np.pi, linspace_count)
sin_v = np.sin(v)
x = center[0] + radius * np.outer(np.cos(u), sin_v)
y = center[1] + radius * np.outer(np.sin(u), sin_v)
z = center[2] + radius * np.outer(np.ones_like(u), np.cos(v))
ax.plot_surface(x, y, z, linewidth=0.0, color=color, alpha=alpha) | [
"def",
"plot_sphere",
"(",
"ax",
",",
"center",
",",
"radius",
",",
"color",
"=",
"'black'",
",",
"alpha",
"=",
"1.",
",",
"linspace_count",
"=",
"_LINSPACE_COUNT",
")",
":",
"u",
"=",
"np",
".",
"linspace",
"(",
"0",
",",
"2",
"*",
"np",
".",
"pi",
",",
"linspace_count",
")",
"v",
"=",
"np",
".",
"linspace",
"(",
"0",
",",
"np",
".",
"pi",
",",
"linspace_count",
")",
"sin_v",
"=",
"np",
".",
"sin",
"(",
"v",
")",
"x",
"=",
"center",
"[",
"0",
"]",
"+",
"radius",
"*",
"np",
".",
"outer",
"(",
"np",
".",
"cos",
"(",
"u",
")",
",",
"sin_v",
")",
"y",
"=",
"center",
"[",
"1",
"]",
"+",
"radius",
"*",
"np",
".",
"outer",
"(",
"np",
".",
"sin",
"(",
"u",
")",
",",
"sin_v",
")",
"z",
"=",
"center",
"[",
"2",
"]",
"+",
"radius",
"*",
"np",
".",
"outer",
"(",
"np",
".",
"ones_like",
"(",
"u",
")",
",",
"np",
".",
"cos",
"(",
"v",
")",
")",
"ax",
".",
"plot_surface",
"(",
"x",
",",
"y",
",",
"z",
",",
"linewidth",
"=",
"0.0",
",",
"color",
"=",
"color",
",",
"alpha",
"=",
"alpha",
")"
] | Plots a 3d sphere, given the center and the radius. | [
"Plots",
"a",
"3d",
"sphere",
"given",
"the",
"center",
"and",
"the",
"radius",
"."
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/view/common.py#L430-L440 | train | 235,450 |
BlueBrain/NeuroM | neurom/check/structural_checks.py | has_sequential_ids | def has_sequential_ids(data_wrapper):
'''Check that IDs are increasing and consecutive
returns tuple (bool, list of IDs that are not consecutive
with their predecessor)
'''
db = data_wrapper.data_block
ids = db[:, COLS.ID]
steps = ids[np.where(np.diff(ids) != 1)[0] + 1].astype(int)
return CheckResult(len(steps) == 0, steps) | python | def has_sequential_ids(data_wrapper):
'''Check that IDs are increasing and consecutive
returns tuple (bool, list of IDs that are not consecutive
with their predecessor)
'''
db = data_wrapper.data_block
ids = db[:, COLS.ID]
steps = ids[np.where(np.diff(ids) != 1)[0] + 1].astype(int)
return CheckResult(len(steps) == 0, steps) | [
"def",
"has_sequential_ids",
"(",
"data_wrapper",
")",
":",
"db",
"=",
"data_wrapper",
".",
"data_block",
"ids",
"=",
"db",
"[",
":",
",",
"COLS",
".",
"ID",
"]",
"steps",
"=",
"ids",
"[",
"np",
".",
"where",
"(",
"np",
".",
"diff",
"(",
"ids",
")",
"!=",
"1",
")",
"[",
"0",
"]",
"+",
"1",
"]",
".",
"astype",
"(",
"int",
")",
"return",
"CheckResult",
"(",
"len",
"(",
"steps",
")",
"==",
"0",
",",
"steps",
")"
] | Check that IDs are increasing and consecutive
returns tuple (bool, list of IDs that are not consecutive
with their predecessor) | [
"Check",
"that",
"IDs",
"are",
"increasing",
"and",
"consecutive"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/check/structural_checks.py#L39-L48 | train | 235,451 |
BlueBrain/NeuroM | neurom/check/structural_checks.py | no_missing_parents | def no_missing_parents(data_wrapper):
'''Check that all points have existing parents
Point's parent ID must exist and parent must be declared
before child.
Returns:
CheckResult with result and list of IDs that have no parent
'''
db = data_wrapper.data_block
ids = np.setdiff1d(db[:, COLS.P], db[:, COLS.ID])[1:]
return CheckResult(len(ids) == 0, ids.astype(np.int) + 1) | python | def no_missing_parents(data_wrapper):
'''Check that all points have existing parents
Point's parent ID must exist and parent must be declared
before child.
Returns:
CheckResult with result and list of IDs that have no parent
'''
db = data_wrapper.data_block
ids = np.setdiff1d(db[:, COLS.P], db[:, COLS.ID])[1:]
return CheckResult(len(ids) == 0, ids.astype(np.int) + 1) | [
"def",
"no_missing_parents",
"(",
"data_wrapper",
")",
":",
"db",
"=",
"data_wrapper",
".",
"data_block",
"ids",
"=",
"np",
".",
"setdiff1d",
"(",
"db",
"[",
":",
",",
"COLS",
".",
"P",
"]",
",",
"db",
"[",
":",
",",
"COLS",
".",
"ID",
"]",
")",
"[",
"1",
":",
"]",
"return",
"CheckResult",
"(",
"len",
"(",
"ids",
")",
"==",
"0",
",",
"ids",
".",
"astype",
"(",
"np",
".",
"int",
")",
"+",
"1",
")"
] | Check that all points have existing parents
Point's parent ID must exist and parent must be declared
before child.
Returns:
CheckResult with result and list of IDs that have no parent | [
"Check",
"that",
"all",
"points",
"have",
"existing",
"parents",
"Point",
"s",
"parent",
"ID",
"must",
"exist",
"and",
"parent",
"must",
"be",
"declared",
"before",
"child",
"."
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/check/structural_checks.py#L51-L61 | train | 235,452 |
BlueBrain/NeuroM | neurom/check/structural_checks.py | is_single_tree | def is_single_tree(data_wrapper):
'''Check that data forms a single tree
Only the first point has ID of -1.
Returns:
CheckResult with result and list of IDs
Note:
This assumes no_missing_parents passed.
'''
db = data_wrapper.data_block
bad_ids = db[db[:, COLS.P] == -1][1:, COLS.ID]
return CheckResult(len(bad_ids) == 0, bad_ids.tolist()) | python | def is_single_tree(data_wrapper):
'''Check that data forms a single tree
Only the first point has ID of -1.
Returns:
CheckResult with result and list of IDs
Note:
This assumes no_missing_parents passed.
'''
db = data_wrapper.data_block
bad_ids = db[db[:, COLS.P] == -1][1:, COLS.ID]
return CheckResult(len(bad_ids) == 0, bad_ids.tolist()) | [
"def",
"is_single_tree",
"(",
"data_wrapper",
")",
":",
"db",
"=",
"data_wrapper",
".",
"data_block",
"bad_ids",
"=",
"db",
"[",
"db",
"[",
":",
",",
"COLS",
".",
"P",
"]",
"==",
"-",
"1",
"]",
"[",
"1",
":",
",",
"COLS",
".",
"ID",
"]",
"return",
"CheckResult",
"(",
"len",
"(",
"bad_ids",
")",
"==",
"0",
",",
"bad_ids",
".",
"tolist",
"(",
")",
")"
] | Check that data forms a single tree
Only the first point has ID of -1.
Returns:
CheckResult with result and list of IDs
Note:
This assumes no_missing_parents passed. | [
"Check",
"that",
"data",
"forms",
"a",
"single",
"tree"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/check/structural_checks.py#L64-L77 | train | 235,453 |
BlueBrain/NeuroM | neurom/check/structural_checks.py | has_soma_points | def has_soma_points(data_wrapper):
'''Checks if the TYPE column of raw data block has an element of type soma
Returns:
CheckResult with result
'''
db = data_wrapper.data_block
return CheckResult(POINT_TYPE.SOMA in db[:, COLS.TYPE], None) | python | def has_soma_points(data_wrapper):
'''Checks if the TYPE column of raw data block has an element of type soma
Returns:
CheckResult with result
'''
db = data_wrapper.data_block
return CheckResult(POINT_TYPE.SOMA in db[:, COLS.TYPE], None) | [
"def",
"has_soma_points",
"(",
"data_wrapper",
")",
":",
"db",
"=",
"data_wrapper",
".",
"data_block",
"return",
"CheckResult",
"(",
"POINT_TYPE",
".",
"SOMA",
"in",
"db",
"[",
":",
",",
"COLS",
".",
"TYPE",
"]",
",",
"None",
")"
] | Checks if the TYPE column of raw data block has an element of type soma
Returns:
CheckResult with result | [
"Checks",
"if",
"the",
"TYPE",
"column",
"of",
"raw",
"data",
"block",
"has",
"an",
"element",
"of",
"type",
"soma"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/check/structural_checks.py#L93-L100 | train | 235,454 |
BlueBrain/NeuroM | neurom/check/structural_checks.py | has_all_finite_radius_neurites | def has_all_finite_radius_neurites(data_wrapper, threshold=0.0):
'''Check that all points with neurite type have a finite radius
Returns:
CheckResult with result and list of IDs of neurite points with zero radius
'''
db = data_wrapper.data_block
neurite_ids = np.in1d(db[:, COLS.TYPE], POINT_TYPE.NEURITES)
zero_radius_ids = db[:, COLS.R] <= threshold
bad_pts = np.array(db[neurite_ids & zero_radius_ids][:, COLS.ID],
dtype=int).tolist()
return CheckResult(len(bad_pts) == 0, bad_pts) | python | def has_all_finite_radius_neurites(data_wrapper, threshold=0.0):
'''Check that all points with neurite type have a finite radius
Returns:
CheckResult with result and list of IDs of neurite points with zero radius
'''
db = data_wrapper.data_block
neurite_ids = np.in1d(db[:, COLS.TYPE], POINT_TYPE.NEURITES)
zero_radius_ids = db[:, COLS.R] <= threshold
bad_pts = np.array(db[neurite_ids & zero_radius_ids][:, COLS.ID],
dtype=int).tolist()
return CheckResult(len(bad_pts) == 0, bad_pts) | [
"def",
"has_all_finite_radius_neurites",
"(",
"data_wrapper",
",",
"threshold",
"=",
"0.0",
")",
":",
"db",
"=",
"data_wrapper",
".",
"data_block",
"neurite_ids",
"=",
"np",
".",
"in1d",
"(",
"db",
"[",
":",
",",
"COLS",
".",
"TYPE",
"]",
",",
"POINT_TYPE",
".",
"NEURITES",
")",
"zero_radius_ids",
"=",
"db",
"[",
":",
",",
"COLS",
".",
"R",
"]",
"<=",
"threshold",
"bad_pts",
"=",
"np",
".",
"array",
"(",
"db",
"[",
"neurite_ids",
"&",
"zero_radius_ids",
"]",
"[",
":",
",",
"COLS",
".",
"ID",
"]",
",",
"dtype",
"=",
"int",
")",
".",
"tolist",
"(",
")",
"return",
"CheckResult",
"(",
"len",
"(",
"bad_pts",
")",
"==",
"0",
",",
"bad_pts",
")"
] | Check that all points with neurite type have a finite radius
Returns:
CheckResult with result and list of IDs of neurite points with zero radius | [
"Check",
"that",
"all",
"points",
"with",
"neurite",
"type",
"have",
"a",
"finite",
"radius"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/check/structural_checks.py#L103-L114 | train | 235,455 |
BlueBrain/NeuroM | neurom/check/structural_checks.py | has_valid_soma | def has_valid_soma(data_wrapper):
'''Check if a data block has a valid soma
Returns:
CheckResult with result
'''
try:
make_soma(data_wrapper.soma_points())
return CheckResult(True)
except SomaError:
return CheckResult(False) | python | def has_valid_soma(data_wrapper):
'''Check if a data block has a valid soma
Returns:
CheckResult with result
'''
try:
make_soma(data_wrapper.soma_points())
return CheckResult(True)
except SomaError:
return CheckResult(False) | [
"def",
"has_valid_soma",
"(",
"data_wrapper",
")",
":",
"try",
":",
"make_soma",
"(",
"data_wrapper",
".",
"soma_points",
"(",
")",
")",
"return",
"CheckResult",
"(",
"True",
")",
"except",
"SomaError",
":",
"return",
"CheckResult",
"(",
"False",
")"
] | Check if a data block has a valid soma
Returns:
CheckResult with result | [
"Check",
"if",
"a",
"data",
"block",
"has",
"a",
"valid",
"soma"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/check/structural_checks.py#L117-L127 | train | 235,456 |
BlueBrain/NeuroM | doc/source/conf.py | _pelita_member_filter | def _pelita_member_filter(parent_name, item_names):
"""
Filter a list of autodoc items for which to generate documentation.
Include only imports that come from the documented module or its
submodules.
"""
filtered_names = []
if parent_name not in sys.modules:
return item_names
module = sys.modules[parent_name]
for item_name in item_names:
item = getattr(module, item_name, None)
location = getattr(item, '__module__', None)
if location is None or (location + ".").startswith(parent_name + "."):
filtered_names.append(item_name)
return filtered_names | python | def _pelita_member_filter(parent_name, item_names):
"""
Filter a list of autodoc items for which to generate documentation.
Include only imports that come from the documented module or its
submodules.
"""
filtered_names = []
if parent_name not in sys.modules:
return item_names
module = sys.modules[parent_name]
for item_name in item_names:
item = getattr(module, item_name, None)
location = getattr(item, '__module__', None)
if location is None or (location + ".").startswith(parent_name + "."):
filtered_names.append(item_name)
return filtered_names | [
"def",
"_pelita_member_filter",
"(",
"parent_name",
",",
"item_names",
")",
":",
"filtered_names",
"=",
"[",
"]",
"if",
"parent_name",
"not",
"in",
"sys",
".",
"modules",
":",
"return",
"item_names",
"module",
"=",
"sys",
".",
"modules",
"[",
"parent_name",
"]",
"for",
"item_name",
"in",
"item_names",
":",
"item",
"=",
"getattr",
"(",
"module",
",",
"item_name",
",",
"None",
")",
"location",
"=",
"getattr",
"(",
"item",
",",
"'__module__'",
",",
"None",
")",
"if",
"location",
"is",
"None",
"or",
"(",
"location",
"+",
"\".\"",
")",
".",
"startswith",
"(",
"parent_name",
"+",
"\".\"",
")",
":",
"filtered_names",
".",
"append",
"(",
"item_name",
")",
"return",
"filtered_names"
] | Filter a list of autodoc items for which to generate documentation.
Include only imports that come from the documented module or its
submodules. | [
"Filter",
"a",
"list",
"of",
"autodoc",
"items",
"for",
"which",
"to",
"generate",
"documentation",
"."
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/doc/source/conf.py#L158-L179 | train | 235,457 |
BlueBrain/NeuroM | neurom/check/neuron_checks.py | has_axon | def has_axon(neuron, treefun=_read_neurite_type):
'''Check if a neuron has an axon
Arguments:
neuron(Neuron): The neuron object to test
treefun: Optional function to calculate the tree type of
neuron's neurites
Returns:
CheckResult with result
'''
return CheckResult(NeuriteType.axon in (treefun(n) for n in neuron.neurites)) | python | def has_axon(neuron, treefun=_read_neurite_type):
'''Check if a neuron has an axon
Arguments:
neuron(Neuron): The neuron object to test
treefun: Optional function to calculate the tree type of
neuron's neurites
Returns:
CheckResult with result
'''
return CheckResult(NeuriteType.axon in (treefun(n) for n in neuron.neurites)) | [
"def",
"has_axon",
"(",
"neuron",
",",
"treefun",
"=",
"_read_neurite_type",
")",
":",
"return",
"CheckResult",
"(",
"NeuriteType",
".",
"axon",
"in",
"(",
"treefun",
"(",
"n",
")",
"for",
"n",
"in",
"neuron",
".",
"neurites",
")",
")"
] | Check if a neuron has an axon
Arguments:
neuron(Neuron): The neuron object to test
treefun: Optional function to calculate the tree type of
neuron's neurites
Returns:
CheckResult with result | [
"Check",
"if",
"a",
"neuron",
"has",
"an",
"axon"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/check/neuron_checks.py#L54-L65 | train | 235,458 |
BlueBrain/NeuroM | neurom/check/neuron_checks.py | has_apical_dendrite | def has_apical_dendrite(neuron, min_number=1, treefun=_read_neurite_type):
'''Check if a neuron has apical dendrites
Arguments:
neuron(Neuron): The neuron object to test
min_number: minimum number of apical dendrites required
treefun: Optional function to calculate the tree type of neuron's
neurites
Returns:
CheckResult with result
'''
types = [treefun(n) for n in neuron.neurites]
return CheckResult(types.count(NeuriteType.apical_dendrite) >= min_number) | python | def has_apical_dendrite(neuron, min_number=1, treefun=_read_neurite_type):
'''Check if a neuron has apical dendrites
Arguments:
neuron(Neuron): The neuron object to test
min_number: minimum number of apical dendrites required
treefun: Optional function to calculate the tree type of neuron's
neurites
Returns:
CheckResult with result
'''
types = [treefun(n) for n in neuron.neurites]
return CheckResult(types.count(NeuriteType.apical_dendrite) >= min_number) | [
"def",
"has_apical_dendrite",
"(",
"neuron",
",",
"min_number",
"=",
"1",
",",
"treefun",
"=",
"_read_neurite_type",
")",
":",
"types",
"=",
"[",
"treefun",
"(",
"n",
")",
"for",
"n",
"in",
"neuron",
".",
"neurites",
"]",
"return",
"CheckResult",
"(",
"types",
".",
"count",
"(",
"NeuriteType",
".",
"apical_dendrite",
")",
">=",
"min_number",
")"
] | Check if a neuron has apical dendrites
Arguments:
neuron(Neuron): The neuron object to test
min_number: minimum number of apical dendrites required
treefun: Optional function to calculate the tree type of neuron's
neurites
Returns:
CheckResult with result | [
"Check",
"if",
"a",
"neuron",
"has",
"apical",
"dendrites"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/check/neuron_checks.py#L68-L81 | train | 235,459 |
BlueBrain/NeuroM | neurom/check/neuron_checks.py | has_basal_dendrite | def has_basal_dendrite(neuron, min_number=1, treefun=_read_neurite_type):
'''Check if a neuron has basal dendrites
Arguments:
neuron(Neuron): The neuron object to test
min_number: minimum number of basal dendrites required
treefun: Optional function to calculate the tree type of neuron's
neurites
Returns:
CheckResult with result
'''
types = [treefun(n) for n in neuron.neurites]
return CheckResult(types.count(NeuriteType.basal_dendrite) >= min_number) | python | def has_basal_dendrite(neuron, min_number=1, treefun=_read_neurite_type):
'''Check if a neuron has basal dendrites
Arguments:
neuron(Neuron): The neuron object to test
min_number: minimum number of basal dendrites required
treefun: Optional function to calculate the tree type of neuron's
neurites
Returns:
CheckResult with result
'''
types = [treefun(n) for n in neuron.neurites]
return CheckResult(types.count(NeuriteType.basal_dendrite) >= min_number) | [
"def",
"has_basal_dendrite",
"(",
"neuron",
",",
"min_number",
"=",
"1",
",",
"treefun",
"=",
"_read_neurite_type",
")",
":",
"types",
"=",
"[",
"treefun",
"(",
"n",
")",
"for",
"n",
"in",
"neuron",
".",
"neurites",
"]",
"return",
"CheckResult",
"(",
"types",
".",
"count",
"(",
"NeuriteType",
".",
"basal_dendrite",
")",
">=",
"min_number",
")"
] | Check if a neuron has basal dendrites
Arguments:
neuron(Neuron): The neuron object to test
min_number: minimum number of basal dendrites required
treefun: Optional function to calculate the tree type of neuron's
neurites
Returns:
CheckResult with result | [
"Check",
"if",
"a",
"neuron",
"has",
"basal",
"dendrites"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/check/neuron_checks.py#L84-L97 | train | 235,460 |
BlueBrain/NeuroM | neurom/check/neuron_checks.py | has_no_flat_neurites | def has_no_flat_neurites(neuron, tol=0.1, method='ratio'):
'''Check that a neuron has no flat neurites
Arguments:
neuron(Neuron): The neuron object to test
tol(float): tolerance
method(string): way of determining flatness, 'tolerance', 'ratio' \
as described in :meth:`neurom.check.morphtree.get_flat_neurites`
Returns:
CheckResult with result
'''
return CheckResult(len(get_flat_neurites(neuron, tol, method)) == 0) | python | def has_no_flat_neurites(neuron, tol=0.1, method='ratio'):
'''Check that a neuron has no flat neurites
Arguments:
neuron(Neuron): The neuron object to test
tol(float): tolerance
method(string): way of determining flatness, 'tolerance', 'ratio' \
as described in :meth:`neurom.check.morphtree.get_flat_neurites`
Returns:
CheckResult with result
'''
return CheckResult(len(get_flat_neurites(neuron, tol, method)) == 0) | [
"def",
"has_no_flat_neurites",
"(",
"neuron",
",",
"tol",
"=",
"0.1",
",",
"method",
"=",
"'ratio'",
")",
":",
"return",
"CheckResult",
"(",
"len",
"(",
"get_flat_neurites",
"(",
"neuron",
",",
"tol",
",",
"method",
")",
")",
"==",
"0",
")"
] | Check that a neuron has no flat neurites
Arguments:
neuron(Neuron): The neuron object to test
tol(float): tolerance
method(string): way of determining flatness, 'tolerance', 'ratio' \
as described in :meth:`neurom.check.morphtree.get_flat_neurites`
Returns:
CheckResult with result | [
"Check",
"that",
"a",
"neuron",
"has",
"no",
"flat",
"neurites"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/check/neuron_checks.py#L100-L112 | train | 235,461 |
BlueBrain/NeuroM | neurom/check/neuron_checks.py | has_all_nonzero_segment_lengths | def has_all_nonzero_segment_lengths(neuron, threshold=0.0):
'''Check presence of neuron segments with length not above threshold
Arguments:
neuron(Neuron): The neuron object to test
threshold(float): value above which a segment length is considered to
be non-zero
Returns:
CheckResult with result including list of (section_id, segment_id)
of zero length segments
'''
bad_ids = []
for sec in _nf.iter_sections(neuron):
p = sec.points
for i, s in enumerate(zip(p[:-1], p[1:])):
if segment_length(s) <= threshold:
bad_ids.append((sec.id, i))
return CheckResult(len(bad_ids) == 0, bad_ids) | python | def has_all_nonzero_segment_lengths(neuron, threshold=0.0):
'''Check presence of neuron segments with length not above threshold
Arguments:
neuron(Neuron): The neuron object to test
threshold(float): value above which a segment length is considered to
be non-zero
Returns:
CheckResult with result including list of (section_id, segment_id)
of zero length segments
'''
bad_ids = []
for sec in _nf.iter_sections(neuron):
p = sec.points
for i, s in enumerate(zip(p[:-1], p[1:])):
if segment_length(s) <= threshold:
bad_ids.append((sec.id, i))
return CheckResult(len(bad_ids) == 0, bad_ids) | [
"def",
"has_all_nonzero_segment_lengths",
"(",
"neuron",
",",
"threshold",
"=",
"0.0",
")",
":",
"bad_ids",
"=",
"[",
"]",
"for",
"sec",
"in",
"_nf",
".",
"iter_sections",
"(",
"neuron",
")",
":",
"p",
"=",
"sec",
".",
"points",
"for",
"i",
",",
"s",
"in",
"enumerate",
"(",
"zip",
"(",
"p",
"[",
":",
"-",
"1",
"]",
",",
"p",
"[",
"1",
":",
"]",
")",
")",
":",
"if",
"segment_length",
"(",
"s",
")",
"<=",
"threshold",
":",
"bad_ids",
".",
"append",
"(",
"(",
"sec",
".",
"id",
",",
"i",
")",
")",
"return",
"CheckResult",
"(",
"len",
"(",
"bad_ids",
")",
"==",
"0",
",",
"bad_ids",
")"
] | Check presence of neuron segments with length not above threshold
Arguments:
neuron(Neuron): The neuron object to test
threshold(float): value above which a segment length is considered to
be non-zero
Returns:
CheckResult with result including list of (section_id, segment_id)
of zero length segments | [
"Check",
"presence",
"of",
"neuron",
"segments",
"with",
"length",
"not",
"above",
"threshold"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/check/neuron_checks.py#L128-L147 | train | 235,462 |
BlueBrain/NeuroM | neurom/check/neuron_checks.py | has_all_nonzero_section_lengths | def has_all_nonzero_section_lengths(neuron, threshold=0.0):
'''Check presence of neuron sections with length not above threshold
Arguments:
neuron(Neuron): The neuron object to test
threshold(float): value above which a section length is considered
to be non-zero
Returns:
CheckResult with result including list of ids of bad sections
'''
bad_ids = [s.id for s in _nf.iter_sections(neuron.neurites)
if section_length(s.points) <= threshold]
return CheckResult(len(bad_ids) == 0, bad_ids) | python | def has_all_nonzero_section_lengths(neuron, threshold=0.0):
'''Check presence of neuron sections with length not above threshold
Arguments:
neuron(Neuron): The neuron object to test
threshold(float): value above which a section length is considered
to be non-zero
Returns:
CheckResult with result including list of ids of bad sections
'''
bad_ids = [s.id for s in _nf.iter_sections(neuron.neurites)
if section_length(s.points) <= threshold]
return CheckResult(len(bad_ids) == 0, bad_ids) | [
"def",
"has_all_nonzero_section_lengths",
"(",
"neuron",
",",
"threshold",
"=",
"0.0",
")",
":",
"bad_ids",
"=",
"[",
"s",
".",
"id",
"for",
"s",
"in",
"_nf",
".",
"iter_sections",
"(",
"neuron",
".",
"neurites",
")",
"if",
"section_length",
"(",
"s",
".",
"points",
")",
"<=",
"threshold",
"]",
"return",
"CheckResult",
"(",
"len",
"(",
"bad_ids",
")",
"==",
"0",
",",
"bad_ids",
")"
] | Check presence of neuron sections with length not above threshold
Arguments:
neuron(Neuron): The neuron object to test
threshold(float): value above which a section length is considered
to be non-zero
Returns:
CheckResult with result including list of ids of bad sections | [
"Check",
"presence",
"of",
"neuron",
"sections",
"with",
"length",
"not",
"above",
"threshold"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/check/neuron_checks.py#L150-L164 | train | 235,463 |
BlueBrain/NeuroM | neurom/check/neuron_checks.py | has_all_nonzero_neurite_radii | def has_all_nonzero_neurite_radii(neuron, threshold=0.0):
'''Check presence of neurite points with radius not above threshold
Arguments:
neuron(Neuron): The neuron object to test
threshold: value above which a radius is considered to be non-zero
Returns:
CheckResult with result including list of (section ID, point ID) pairs
of zero-radius points
'''
bad_ids = []
seen_ids = set()
for s in _nf.iter_sections(neuron):
for i, p in enumerate(s.points):
info = (s.id, i)
if p[COLS.R] <= threshold and info not in seen_ids:
seen_ids.add(info)
bad_ids.append(info)
return CheckResult(len(bad_ids) == 0, bad_ids) | python | def has_all_nonzero_neurite_radii(neuron, threshold=0.0):
'''Check presence of neurite points with radius not above threshold
Arguments:
neuron(Neuron): The neuron object to test
threshold: value above which a radius is considered to be non-zero
Returns:
CheckResult with result including list of (section ID, point ID) pairs
of zero-radius points
'''
bad_ids = []
seen_ids = set()
for s in _nf.iter_sections(neuron):
for i, p in enumerate(s.points):
info = (s.id, i)
if p[COLS.R] <= threshold and info not in seen_ids:
seen_ids.add(info)
bad_ids.append(info)
return CheckResult(len(bad_ids) == 0, bad_ids) | [
"def",
"has_all_nonzero_neurite_radii",
"(",
"neuron",
",",
"threshold",
"=",
"0.0",
")",
":",
"bad_ids",
"=",
"[",
"]",
"seen_ids",
"=",
"set",
"(",
")",
"for",
"s",
"in",
"_nf",
".",
"iter_sections",
"(",
"neuron",
")",
":",
"for",
"i",
",",
"p",
"in",
"enumerate",
"(",
"s",
".",
"points",
")",
":",
"info",
"=",
"(",
"s",
".",
"id",
",",
"i",
")",
"if",
"p",
"[",
"COLS",
".",
"R",
"]",
"<=",
"threshold",
"and",
"info",
"not",
"in",
"seen_ids",
":",
"seen_ids",
".",
"add",
"(",
"info",
")",
"bad_ids",
".",
"append",
"(",
"info",
")",
"return",
"CheckResult",
"(",
"len",
"(",
"bad_ids",
")",
"==",
"0",
",",
"bad_ids",
")"
] | Check presence of neurite points with radius not above threshold
Arguments:
neuron(Neuron): The neuron object to test
threshold: value above which a radius is considered to be non-zero
Returns:
CheckResult with result including list of (section ID, point ID) pairs
of zero-radius points | [
"Check",
"presence",
"of",
"neurite",
"points",
"with",
"radius",
"not",
"above",
"threshold"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/check/neuron_checks.py#L167-L187 | train | 235,464 |
BlueBrain/NeuroM | neurom/check/neuron_checks.py | has_no_fat_ends | def has_no_fat_ends(neuron, multiple_of_mean=2.0, final_point_count=5):
'''Check if leaf points are too large
Arguments:
neuron(Neuron): The neuron object to test
multiple_of_mean(float): how many times larger the final radius
has to be compared to the mean of the final points
final_point_count(int): how many points to include in the mean
Returns:
CheckResult with result list of ids of bad sections
Note:
A fat end is defined as a leaf segment whose last point is larger
by a factor of `multiple_of_mean` than the mean of the points in
`final_point_count`
'''
bad_ids = []
for leaf in _nf.iter_sections(neuron.neurites, iterator_type=Tree.ileaf):
mean_radius = np.mean(leaf.points[1:][-final_point_count:, COLS.R])
if mean_radius * multiple_of_mean <= leaf.points[-1, COLS.R]:
bad_ids.append((leaf.id, leaf.points[-1:]))
return CheckResult(len(bad_ids) == 0, bad_ids) | python | def has_no_fat_ends(neuron, multiple_of_mean=2.0, final_point_count=5):
'''Check if leaf points are too large
Arguments:
neuron(Neuron): The neuron object to test
multiple_of_mean(float): how many times larger the final radius
has to be compared to the mean of the final points
final_point_count(int): how many points to include in the mean
Returns:
CheckResult with result list of ids of bad sections
Note:
A fat end is defined as a leaf segment whose last point is larger
by a factor of `multiple_of_mean` than the mean of the points in
`final_point_count`
'''
bad_ids = []
for leaf in _nf.iter_sections(neuron.neurites, iterator_type=Tree.ileaf):
mean_radius = np.mean(leaf.points[1:][-final_point_count:, COLS.R])
if mean_radius * multiple_of_mean <= leaf.points[-1, COLS.R]:
bad_ids.append((leaf.id, leaf.points[-1:]))
return CheckResult(len(bad_ids) == 0, bad_ids) | [
"def",
"has_no_fat_ends",
"(",
"neuron",
",",
"multiple_of_mean",
"=",
"2.0",
",",
"final_point_count",
"=",
"5",
")",
":",
"bad_ids",
"=",
"[",
"]",
"for",
"leaf",
"in",
"_nf",
".",
"iter_sections",
"(",
"neuron",
".",
"neurites",
",",
"iterator_type",
"=",
"Tree",
".",
"ileaf",
")",
":",
"mean_radius",
"=",
"np",
".",
"mean",
"(",
"leaf",
".",
"points",
"[",
"1",
":",
"]",
"[",
"-",
"final_point_count",
":",
",",
"COLS",
".",
"R",
"]",
")",
"if",
"mean_radius",
"*",
"multiple_of_mean",
"<=",
"leaf",
".",
"points",
"[",
"-",
"1",
",",
"COLS",
".",
"R",
"]",
":",
"bad_ids",
".",
"append",
"(",
"(",
"leaf",
".",
"id",
",",
"leaf",
".",
"points",
"[",
"-",
"1",
":",
"]",
")",
")",
"return",
"CheckResult",
"(",
"len",
"(",
"bad_ids",
")",
"==",
"0",
",",
"bad_ids",
")"
] | Check if leaf points are too large
Arguments:
neuron(Neuron): The neuron object to test
multiple_of_mean(float): how many times larger the final radius
has to be compared to the mean of the final points
final_point_count(int): how many points to include in the mean
Returns:
CheckResult with result list of ids of bad sections
Note:
A fat end is defined as a leaf segment whose last point is larger
by a factor of `multiple_of_mean` than the mean of the points in
`final_point_count` | [
"Check",
"if",
"leaf",
"points",
"are",
"too",
"large"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/check/neuron_checks.py#L226-L250 | train | 235,465 |
BlueBrain/NeuroM | neurom/check/neuron_checks.py | has_no_narrow_start | def has_no_narrow_start(neuron, frac=0.9):
'''Check if neurites have a narrow start
Arguments:
neuron(Neuron): The neuron object to test
frac(float): Ratio that the second point must be smaller than the first
Returns:
CheckResult with a list of all first segments of neurites with a narrow start
'''
bad_ids = [(neurite.root_node.id, [neurite.root_node.points[1]])
for neurite in neuron.neurites
if neurite.root_node.points[1][COLS.R] < frac * neurite.root_node.points[2][COLS.R]]
return CheckResult(len(bad_ids) == 0, bad_ids) | python | def has_no_narrow_start(neuron, frac=0.9):
'''Check if neurites have a narrow start
Arguments:
neuron(Neuron): The neuron object to test
frac(float): Ratio that the second point must be smaller than the first
Returns:
CheckResult with a list of all first segments of neurites with a narrow start
'''
bad_ids = [(neurite.root_node.id, [neurite.root_node.points[1]])
for neurite in neuron.neurites
if neurite.root_node.points[1][COLS.R] < frac * neurite.root_node.points[2][COLS.R]]
return CheckResult(len(bad_ids) == 0, bad_ids) | [
"def",
"has_no_narrow_start",
"(",
"neuron",
",",
"frac",
"=",
"0.9",
")",
":",
"bad_ids",
"=",
"[",
"(",
"neurite",
".",
"root_node",
".",
"id",
",",
"[",
"neurite",
".",
"root_node",
".",
"points",
"[",
"1",
"]",
"]",
")",
"for",
"neurite",
"in",
"neuron",
".",
"neurites",
"if",
"neurite",
".",
"root_node",
".",
"points",
"[",
"1",
"]",
"[",
"COLS",
".",
"R",
"]",
"<",
"frac",
"*",
"neurite",
".",
"root_node",
".",
"points",
"[",
"2",
"]",
"[",
"COLS",
".",
"R",
"]",
"]",
"return",
"CheckResult",
"(",
"len",
"(",
"bad_ids",
")",
"==",
"0",
",",
"bad_ids",
")"
] | Check if neurites have a narrow start
Arguments:
neuron(Neuron): The neuron object to test
frac(float): Ratio that the second point must be smaller than the first
Returns:
CheckResult with a list of all first segments of neurites with a narrow start | [
"Check",
"if",
"neurites",
"have",
"a",
"narrow",
"start"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/check/neuron_checks.py#L253-L266 | train | 235,466 |
BlueBrain/NeuroM | neurom/check/neuron_checks.py | has_no_dangling_branch | def has_no_dangling_branch(neuron):
'''Check if the neuron has dangling neurites'''
soma_center = neuron.soma.points[:, COLS.XYZ].mean(axis=0)
recentered_soma = neuron.soma.points[:, COLS.XYZ] - soma_center
radius = np.linalg.norm(recentered_soma, axis=1)
soma_max_radius = radius.max()
def is_dangling(neurite):
'''Is the neurite dangling ?'''
starting_point = neurite.points[1][COLS.XYZ]
if np.linalg.norm(starting_point - soma_center) - soma_max_radius <= 12.:
return False
if neurite.type != NeuriteType.axon:
return True
all_points = list(chain.from_iterable(n.points[1:]
for n in iter_neurites(neurite)
if n.type != NeuriteType.axon))
res = [np.linalg.norm(starting_point - p[COLS.XYZ]) >= 2 * p[COLS.R] + 2
for p in all_points]
return all(res)
bad_ids = [(n.root_node.id, [n.root_node.points[1]])
for n in iter_neurites(neuron) if is_dangling(n)]
return CheckResult(len(bad_ids) == 0, bad_ids) | python | def has_no_dangling_branch(neuron):
'''Check if the neuron has dangling neurites'''
soma_center = neuron.soma.points[:, COLS.XYZ].mean(axis=0)
recentered_soma = neuron.soma.points[:, COLS.XYZ] - soma_center
radius = np.linalg.norm(recentered_soma, axis=1)
soma_max_radius = radius.max()
def is_dangling(neurite):
'''Is the neurite dangling ?'''
starting_point = neurite.points[1][COLS.XYZ]
if np.linalg.norm(starting_point - soma_center) - soma_max_radius <= 12.:
return False
if neurite.type != NeuriteType.axon:
return True
all_points = list(chain.from_iterable(n.points[1:]
for n in iter_neurites(neurite)
if n.type != NeuriteType.axon))
res = [np.linalg.norm(starting_point - p[COLS.XYZ]) >= 2 * p[COLS.R] + 2
for p in all_points]
return all(res)
bad_ids = [(n.root_node.id, [n.root_node.points[1]])
for n in iter_neurites(neuron) if is_dangling(n)]
return CheckResult(len(bad_ids) == 0, bad_ids) | [
"def",
"has_no_dangling_branch",
"(",
"neuron",
")",
":",
"soma_center",
"=",
"neuron",
".",
"soma",
".",
"points",
"[",
":",
",",
"COLS",
".",
"XYZ",
"]",
".",
"mean",
"(",
"axis",
"=",
"0",
")",
"recentered_soma",
"=",
"neuron",
".",
"soma",
".",
"points",
"[",
":",
",",
"COLS",
".",
"XYZ",
"]",
"-",
"soma_center",
"radius",
"=",
"np",
".",
"linalg",
".",
"norm",
"(",
"recentered_soma",
",",
"axis",
"=",
"1",
")",
"soma_max_radius",
"=",
"radius",
".",
"max",
"(",
")",
"def",
"is_dangling",
"(",
"neurite",
")",
":",
"'''Is the neurite dangling ?'''",
"starting_point",
"=",
"neurite",
".",
"points",
"[",
"1",
"]",
"[",
"COLS",
".",
"XYZ",
"]",
"if",
"np",
".",
"linalg",
".",
"norm",
"(",
"starting_point",
"-",
"soma_center",
")",
"-",
"soma_max_radius",
"<=",
"12.",
":",
"return",
"False",
"if",
"neurite",
".",
"type",
"!=",
"NeuriteType",
".",
"axon",
":",
"return",
"True",
"all_points",
"=",
"list",
"(",
"chain",
".",
"from_iterable",
"(",
"n",
".",
"points",
"[",
"1",
":",
"]",
"for",
"n",
"in",
"iter_neurites",
"(",
"neurite",
")",
"if",
"n",
".",
"type",
"!=",
"NeuriteType",
".",
"axon",
")",
")",
"res",
"=",
"[",
"np",
".",
"linalg",
".",
"norm",
"(",
"starting_point",
"-",
"p",
"[",
"COLS",
".",
"XYZ",
"]",
")",
">=",
"2",
"*",
"p",
"[",
"COLS",
".",
"R",
"]",
"+",
"2",
"for",
"p",
"in",
"all_points",
"]",
"return",
"all",
"(",
"res",
")",
"bad_ids",
"=",
"[",
"(",
"n",
".",
"root_node",
".",
"id",
",",
"[",
"n",
".",
"root_node",
".",
"points",
"[",
"1",
"]",
"]",
")",
"for",
"n",
"in",
"iter_neurites",
"(",
"neuron",
")",
"if",
"is_dangling",
"(",
"n",
")",
"]",
"return",
"CheckResult",
"(",
"len",
"(",
"bad_ids",
")",
"==",
"0",
",",
"bad_ids",
")"
] | Check if the neuron has dangling neurites | [
"Check",
"if",
"the",
"neuron",
"has",
"dangling",
"neurites"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/check/neuron_checks.py#L269-L295 | train | 235,467 |
BlueBrain/NeuroM | neurom/check/neuron_checks.py | has_no_narrow_neurite_section | def has_no_narrow_neurite_section(neuron,
neurite_filter,
radius_threshold=0.05,
considered_section_min_length=50):
'''Check if the neuron has dendrites with narrow sections
Arguments:
neuron(Neuron): The neuron object to test
neurite_filter(callable): filter the neurites by this callable
radius_threshold(float): radii below this are considered narro
considered_section_min_length(float): sections with length below
this are not taken into account
Returns:
CheckResult with result. result.info contains the narrow section ids and their
first point
'''
considered_sections = (sec for sec in iter_sections(neuron, neurite_filter=neurite_filter)
if sec.length > considered_section_min_length)
def narrow_section(section):
'''Select narrow sections'''
return section.points[:, COLS.R].mean() < radius_threshold
bad_ids = [(section.id, section.points[1])
for section in considered_sections if narrow_section(section)]
return CheckResult(len(bad_ids) == 0, bad_ids) | python | def has_no_narrow_neurite_section(neuron,
neurite_filter,
radius_threshold=0.05,
considered_section_min_length=50):
'''Check if the neuron has dendrites with narrow sections
Arguments:
neuron(Neuron): The neuron object to test
neurite_filter(callable): filter the neurites by this callable
radius_threshold(float): radii below this are considered narro
considered_section_min_length(float): sections with length below
this are not taken into account
Returns:
CheckResult with result. result.info contains the narrow section ids and their
first point
'''
considered_sections = (sec for sec in iter_sections(neuron, neurite_filter=neurite_filter)
if sec.length > considered_section_min_length)
def narrow_section(section):
'''Select narrow sections'''
return section.points[:, COLS.R].mean() < radius_threshold
bad_ids = [(section.id, section.points[1])
for section in considered_sections if narrow_section(section)]
return CheckResult(len(bad_ids) == 0, bad_ids) | [
"def",
"has_no_narrow_neurite_section",
"(",
"neuron",
",",
"neurite_filter",
",",
"radius_threshold",
"=",
"0.05",
",",
"considered_section_min_length",
"=",
"50",
")",
":",
"considered_sections",
"=",
"(",
"sec",
"for",
"sec",
"in",
"iter_sections",
"(",
"neuron",
",",
"neurite_filter",
"=",
"neurite_filter",
")",
"if",
"sec",
".",
"length",
">",
"considered_section_min_length",
")",
"def",
"narrow_section",
"(",
"section",
")",
":",
"'''Select narrow sections'''",
"return",
"section",
".",
"points",
"[",
":",
",",
"COLS",
".",
"R",
"]",
".",
"mean",
"(",
")",
"<",
"radius_threshold",
"bad_ids",
"=",
"[",
"(",
"section",
".",
"id",
",",
"section",
".",
"points",
"[",
"1",
"]",
")",
"for",
"section",
"in",
"considered_sections",
"if",
"narrow_section",
"(",
"section",
")",
"]",
"return",
"CheckResult",
"(",
"len",
"(",
"bad_ids",
")",
"==",
"0",
",",
"bad_ids",
")"
] | Check if the neuron has dendrites with narrow sections
Arguments:
neuron(Neuron): The neuron object to test
neurite_filter(callable): filter the neurites by this callable
radius_threshold(float): radii below this are considered narro
considered_section_min_length(float): sections with length below
this are not taken into account
Returns:
CheckResult with result. result.info contains the narrow section ids and their
first point | [
"Check",
"if",
"the",
"neuron",
"has",
"dendrites",
"with",
"narrow",
"sections"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/check/neuron_checks.py#L298-L325 | train | 235,468 |
BlueBrain/NeuroM | examples/synthesis_json.py | transform_header | def transform_header(mtype_name):
'''Add header to json output to wrap around distribution data.
'''
head_dict = OrderedDict()
head_dict["m-type"] = mtype_name
head_dict["components"] = defaultdict(OrderedDict)
return head_dict | python | def transform_header(mtype_name):
'''Add header to json output to wrap around distribution data.
'''
head_dict = OrderedDict()
head_dict["m-type"] = mtype_name
head_dict["components"] = defaultdict(OrderedDict)
return head_dict | [
"def",
"transform_header",
"(",
"mtype_name",
")",
":",
"head_dict",
"=",
"OrderedDict",
"(",
")",
"head_dict",
"[",
"\"m-type\"",
"]",
"=",
"mtype_name",
"head_dict",
"[",
"\"components\"",
"]",
"=",
"defaultdict",
"(",
"OrderedDict",
")",
"return",
"head_dict"
] | Add header to json output to wrap around distribution data. | [
"Add",
"header",
"to",
"json",
"output",
"to",
"wrap",
"around",
"distribution",
"data",
"."
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/examples/synthesis_json.py#L92-L100 | train | 235,469 |
BlueBrain/NeuroM | neurom/view/plotly.py | draw | def draw(obj, plane='3d', inline=False, **kwargs):
'''Draw the morphology using in the given plane
plane (str): a string representing the 2D plane (example: 'xy')
or '3d', '3D' for a 3D view
inline (bool): must be set to True for interactive ipython notebook plotting
'''
if plane.lower() == '3d':
return _plot_neuron3d(obj, inline, **kwargs)
return _plot_neuron(obj, plane, inline, **kwargs) | python | def draw(obj, plane='3d', inline=False, **kwargs):
'''Draw the morphology using in the given plane
plane (str): a string representing the 2D plane (example: 'xy')
or '3d', '3D' for a 3D view
inline (bool): must be set to True for interactive ipython notebook plotting
'''
if plane.lower() == '3d':
return _plot_neuron3d(obj, inline, **kwargs)
return _plot_neuron(obj, plane, inline, **kwargs) | [
"def",
"draw",
"(",
"obj",
",",
"plane",
"=",
"'3d'",
",",
"inline",
"=",
"False",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"plane",
".",
"lower",
"(",
")",
"==",
"'3d'",
":",
"return",
"_plot_neuron3d",
"(",
"obj",
",",
"inline",
",",
"*",
"*",
"kwargs",
")",
"return",
"_plot_neuron",
"(",
"obj",
",",
"plane",
",",
"inline",
",",
"*",
"*",
"kwargs",
")"
] | Draw the morphology using in the given plane
plane (str): a string representing the 2D plane (example: 'xy')
or '3d', '3D' for a 3D view
inline (bool): must be set to True for interactive ipython notebook plotting | [
"Draw",
"the",
"morphology",
"using",
"in",
"the",
"given",
"plane"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/view/plotly.py#L21-L31 | train | 235,470 |
BlueBrain/NeuroM | neurom/view/plotly.py | _make_trace | def _make_trace(neuron, plane):
'''Create the trace to be plotted'''
for neurite in iter_neurites(neuron):
segments = list(iter_segments(neurite))
segs = [(s[0][COLS.XYZ], s[1][COLS.XYZ]) for s in segments]
coords = dict(x=list(chain.from_iterable((p1[0], p2[0], None) for p1, p2 in segs)),
y=list(chain.from_iterable((p1[1], p2[1], None) for p1, p2 in segs)),
z=list(chain.from_iterable((p1[2], p2[2], None) for p1, p2 in segs)))
color = TREE_COLOR.get(neurite.root_node.type, 'black')
if plane.lower() == '3d':
plot_fun = go.Scatter3d
else:
plot_fun = go.Scatter
coords = dict(x=coords[plane[0]], y=coords[plane[1]])
yield plot_fun(
line=dict(color=color, width=2),
mode='lines',
**coords
) | python | def _make_trace(neuron, plane):
'''Create the trace to be plotted'''
for neurite in iter_neurites(neuron):
segments = list(iter_segments(neurite))
segs = [(s[0][COLS.XYZ], s[1][COLS.XYZ]) for s in segments]
coords = dict(x=list(chain.from_iterable((p1[0], p2[0], None) for p1, p2 in segs)),
y=list(chain.from_iterable((p1[1], p2[1], None) for p1, p2 in segs)),
z=list(chain.from_iterable((p1[2], p2[2], None) for p1, p2 in segs)))
color = TREE_COLOR.get(neurite.root_node.type, 'black')
if plane.lower() == '3d':
plot_fun = go.Scatter3d
else:
plot_fun = go.Scatter
coords = dict(x=coords[plane[0]], y=coords[plane[1]])
yield plot_fun(
line=dict(color=color, width=2),
mode='lines',
**coords
) | [
"def",
"_make_trace",
"(",
"neuron",
",",
"plane",
")",
":",
"for",
"neurite",
"in",
"iter_neurites",
"(",
"neuron",
")",
":",
"segments",
"=",
"list",
"(",
"iter_segments",
"(",
"neurite",
")",
")",
"segs",
"=",
"[",
"(",
"s",
"[",
"0",
"]",
"[",
"COLS",
".",
"XYZ",
"]",
",",
"s",
"[",
"1",
"]",
"[",
"COLS",
".",
"XYZ",
"]",
")",
"for",
"s",
"in",
"segments",
"]",
"coords",
"=",
"dict",
"(",
"x",
"=",
"list",
"(",
"chain",
".",
"from_iterable",
"(",
"(",
"p1",
"[",
"0",
"]",
",",
"p2",
"[",
"0",
"]",
",",
"None",
")",
"for",
"p1",
",",
"p2",
"in",
"segs",
")",
")",
",",
"y",
"=",
"list",
"(",
"chain",
".",
"from_iterable",
"(",
"(",
"p1",
"[",
"1",
"]",
",",
"p2",
"[",
"1",
"]",
",",
"None",
")",
"for",
"p1",
",",
"p2",
"in",
"segs",
")",
")",
",",
"z",
"=",
"list",
"(",
"chain",
".",
"from_iterable",
"(",
"(",
"p1",
"[",
"2",
"]",
",",
"p2",
"[",
"2",
"]",
",",
"None",
")",
"for",
"p1",
",",
"p2",
"in",
"segs",
")",
")",
")",
"color",
"=",
"TREE_COLOR",
".",
"get",
"(",
"neurite",
".",
"root_node",
".",
"type",
",",
"'black'",
")",
"if",
"plane",
".",
"lower",
"(",
")",
"==",
"'3d'",
":",
"plot_fun",
"=",
"go",
".",
"Scatter3d",
"else",
":",
"plot_fun",
"=",
"go",
".",
"Scatter",
"coords",
"=",
"dict",
"(",
"x",
"=",
"coords",
"[",
"plane",
"[",
"0",
"]",
"]",
",",
"y",
"=",
"coords",
"[",
"plane",
"[",
"1",
"]",
"]",
")",
"yield",
"plot_fun",
"(",
"line",
"=",
"dict",
"(",
"color",
"=",
"color",
",",
"width",
"=",
"2",
")",
",",
"mode",
"=",
"'lines'",
",",
"*",
"*",
"coords",
")"
] | Create the trace to be plotted | [
"Create",
"the",
"trace",
"to",
"be",
"plotted"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/view/plotly.py#L46-L67 | train | 235,471 |
BlueBrain/NeuroM | neurom/view/plotly.py | get_figure | def get_figure(neuron, plane, title):
'''Returns the plotly figure containing the neuron'''
data = list(_make_trace(neuron, plane))
axis = dict(
gridcolor='rgb(255, 255, 255)',
zerolinecolor='rgb(255, 255, 255)',
showbackground=True,
backgroundcolor='rgb(230, 230,230)'
)
if plane != '3d':
soma_2d = [
# filled circle
{
'type': 'circle',
'xref': 'x',
'yref': 'y',
'fillcolor': 'rgba(50, 171, 96, 0.7)',
'x0': neuron.soma.center[0] - neuron.soma.radius,
'y0': neuron.soma.center[1] - neuron.soma.radius,
'x1': neuron.soma.center[0] + neuron.soma.radius,
'y1': neuron.soma.center[1] + neuron.soma.radius,
'line': {
'color': 'rgba(50, 171, 96, 1)',
},
},
]
else:
soma_2d = []
theta = np.linspace(0, 2 * np.pi, 100)
phi = np.linspace(0, np.pi, 100)
z = np.outer(np.ones(100), np.cos(phi)) + neuron.soma.center[2]
r = neuron.soma.radius
data.append(
go.Surface(
x=(np.outer(np.cos(theta), np.sin(phi)) + neuron.soma.center[0]) * r,
y=(np.outer(np.sin(theta), np.sin(phi)) + neuron.soma.center[1]) * r,
z=z * r,
cauto=False,
surfacecolor=['black'] * len(z),
showscale=False,
)
)
layout = dict(
autosize=True,
title=title,
scene=dict( # This is used for 3D plots
xaxis=axis, yaxis=axis, zaxis=axis,
camera=dict(up=dict(x=0, y=0, z=1), eye=dict(x=-1.7428, y=1.0707, z=0.7100,)),
aspectmode='data'
),
yaxis=dict(scaleanchor="x"), # This is used for 2D plots
shapes=soma_2d,
)
res = dict(data=data, layout=layout)
return res | python | def get_figure(neuron, plane, title):
'''Returns the plotly figure containing the neuron'''
data = list(_make_trace(neuron, plane))
axis = dict(
gridcolor='rgb(255, 255, 255)',
zerolinecolor='rgb(255, 255, 255)',
showbackground=True,
backgroundcolor='rgb(230, 230,230)'
)
if plane != '3d':
soma_2d = [
# filled circle
{
'type': 'circle',
'xref': 'x',
'yref': 'y',
'fillcolor': 'rgba(50, 171, 96, 0.7)',
'x0': neuron.soma.center[0] - neuron.soma.radius,
'y0': neuron.soma.center[1] - neuron.soma.radius,
'x1': neuron.soma.center[0] + neuron.soma.radius,
'y1': neuron.soma.center[1] + neuron.soma.radius,
'line': {
'color': 'rgba(50, 171, 96, 1)',
},
},
]
else:
soma_2d = []
theta = np.linspace(0, 2 * np.pi, 100)
phi = np.linspace(0, np.pi, 100)
z = np.outer(np.ones(100), np.cos(phi)) + neuron.soma.center[2]
r = neuron.soma.radius
data.append(
go.Surface(
x=(np.outer(np.cos(theta), np.sin(phi)) + neuron.soma.center[0]) * r,
y=(np.outer(np.sin(theta), np.sin(phi)) + neuron.soma.center[1]) * r,
z=z * r,
cauto=False,
surfacecolor=['black'] * len(z),
showscale=False,
)
)
layout = dict(
autosize=True,
title=title,
scene=dict( # This is used for 3D plots
xaxis=axis, yaxis=axis, zaxis=axis,
camera=dict(up=dict(x=0, y=0, z=1), eye=dict(x=-1.7428, y=1.0707, z=0.7100,)),
aspectmode='data'
),
yaxis=dict(scaleanchor="x"), # This is used for 2D plots
shapes=soma_2d,
)
res = dict(data=data, layout=layout)
return res | [
"def",
"get_figure",
"(",
"neuron",
",",
"plane",
",",
"title",
")",
":",
"data",
"=",
"list",
"(",
"_make_trace",
"(",
"neuron",
",",
"plane",
")",
")",
"axis",
"=",
"dict",
"(",
"gridcolor",
"=",
"'rgb(255, 255, 255)'",
",",
"zerolinecolor",
"=",
"'rgb(255, 255, 255)'",
",",
"showbackground",
"=",
"True",
",",
"backgroundcolor",
"=",
"'rgb(230, 230,230)'",
")",
"if",
"plane",
"!=",
"'3d'",
":",
"soma_2d",
"=",
"[",
"# filled circle",
"{",
"'type'",
":",
"'circle'",
",",
"'xref'",
":",
"'x'",
",",
"'yref'",
":",
"'y'",
",",
"'fillcolor'",
":",
"'rgba(50, 171, 96, 0.7)'",
",",
"'x0'",
":",
"neuron",
".",
"soma",
".",
"center",
"[",
"0",
"]",
"-",
"neuron",
".",
"soma",
".",
"radius",
",",
"'y0'",
":",
"neuron",
".",
"soma",
".",
"center",
"[",
"1",
"]",
"-",
"neuron",
".",
"soma",
".",
"radius",
",",
"'x1'",
":",
"neuron",
".",
"soma",
".",
"center",
"[",
"0",
"]",
"+",
"neuron",
".",
"soma",
".",
"radius",
",",
"'y1'",
":",
"neuron",
".",
"soma",
".",
"center",
"[",
"1",
"]",
"+",
"neuron",
".",
"soma",
".",
"radius",
",",
"'line'",
":",
"{",
"'color'",
":",
"'rgba(50, 171, 96, 1)'",
",",
"}",
",",
"}",
",",
"]",
"else",
":",
"soma_2d",
"=",
"[",
"]",
"theta",
"=",
"np",
".",
"linspace",
"(",
"0",
",",
"2",
"*",
"np",
".",
"pi",
",",
"100",
")",
"phi",
"=",
"np",
".",
"linspace",
"(",
"0",
",",
"np",
".",
"pi",
",",
"100",
")",
"z",
"=",
"np",
".",
"outer",
"(",
"np",
".",
"ones",
"(",
"100",
")",
",",
"np",
".",
"cos",
"(",
"phi",
")",
")",
"+",
"neuron",
".",
"soma",
".",
"center",
"[",
"2",
"]",
"r",
"=",
"neuron",
".",
"soma",
".",
"radius",
"data",
".",
"append",
"(",
"go",
".",
"Surface",
"(",
"x",
"=",
"(",
"np",
".",
"outer",
"(",
"np",
".",
"cos",
"(",
"theta",
")",
",",
"np",
".",
"sin",
"(",
"phi",
")",
")",
"+",
"neuron",
".",
"soma",
".",
"center",
"[",
"0",
"]",
")",
"*",
"r",
",",
"y",
"=",
"(",
"np",
".",
"outer",
"(",
"np",
".",
"sin",
"(",
"theta",
")",
",",
"np",
".",
"sin",
"(",
"phi",
")",
")",
"+",
"neuron",
".",
"soma",
".",
"center",
"[",
"1",
"]",
")",
"*",
"r",
",",
"z",
"=",
"z",
"*",
"r",
",",
"cauto",
"=",
"False",
",",
"surfacecolor",
"=",
"[",
"'black'",
"]",
"*",
"len",
"(",
"z",
")",
",",
"showscale",
"=",
"False",
",",
")",
")",
"layout",
"=",
"dict",
"(",
"autosize",
"=",
"True",
",",
"title",
"=",
"title",
",",
"scene",
"=",
"dict",
"(",
"# This is used for 3D plots",
"xaxis",
"=",
"axis",
",",
"yaxis",
"=",
"axis",
",",
"zaxis",
"=",
"axis",
",",
"camera",
"=",
"dict",
"(",
"up",
"=",
"dict",
"(",
"x",
"=",
"0",
",",
"y",
"=",
"0",
",",
"z",
"=",
"1",
")",
",",
"eye",
"=",
"dict",
"(",
"x",
"=",
"-",
"1.7428",
",",
"y",
"=",
"1.0707",
",",
"z",
"=",
"0.7100",
",",
")",
")",
",",
"aspectmode",
"=",
"'data'",
")",
",",
"yaxis",
"=",
"dict",
"(",
"scaleanchor",
"=",
"\"x\"",
")",
",",
"# This is used for 2D plots",
"shapes",
"=",
"soma_2d",
",",
")",
"res",
"=",
"dict",
"(",
"data",
"=",
"data",
",",
"layout",
"=",
"layout",
")",
"return",
"res"
] | Returns the plotly figure containing the neuron | [
"Returns",
"the",
"plotly",
"figure",
"containing",
"the",
"neuron"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/view/plotly.py#L70-L129 | train | 235,472 |
BlueBrain/NeuroM | neurom/geom/transform.py | rotate | def rotate(obj, axis, angle, origin=None):
'''
Rotation around unit vector following the right hand rule
Parameters:
obj : obj to be rotated (e.g. neurite, neuron).
Must implement a transform method.
axis : unit vector for the axis of rotation
angle : rotation angle in rads
Returns:
A copy of the object with the applied translation.
'''
R = _rodrigues_to_dcm(axis, angle)
try:
return obj.transform(PivotRotation(R, origin))
except AttributeError:
raise NotImplementedError | python | def rotate(obj, axis, angle, origin=None):
'''
Rotation around unit vector following the right hand rule
Parameters:
obj : obj to be rotated (e.g. neurite, neuron).
Must implement a transform method.
axis : unit vector for the axis of rotation
angle : rotation angle in rads
Returns:
A copy of the object with the applied translation.
'''
R = _rodrigues_to_dcm(axis, angle)
try:
return obj.transform(PivotRotation(R, origin))
except AttributeError:
raise NotImplementedError | [
"def",
"rotate",
"(",
"obj",
",",
"axis",
",",
"angle",
",",
"origin",
"=",
"None",
")",
":",
"R",
"=",
"_rodrigues_to_dcm",
"(",
"axis",
",",
"angle",
")",
"try",
":",
"return",
"obj",
".",
"transform",
"(",
"PivotRotation",
"(",
"R",
",",
"origin",
")",
")",
"except",
"AttributeError",
":",
"raise",
"NotImplementedError"
] | Rotation around unit vector following the right hand rule
Parameters:
obj : obj to be rotated (e.g. neurite, neuron).
Must implement a transform method.
axis : unit vector for the axis of rotation
angle : rotation angle in rads
Returns:
A copy of the object with the applied translation. | [
"Rotation",
"around",
"unit",
"vector",
"following",
"the",
"right",
"hand",
"rule"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/geom/transform.py#L128-L146 | train | 235,473 |
BlueBrain/NeuroM | neurom/geom/transform.py | _sin | def _sin(x):
'''sine with case for pi multiples'''
return 0. if np.isclose(np.mod(x, np.pi), 0.) else np.sin(x) | python | def _sin(x):
'''sine with case for pi multiples'''
return 0. if np.isclose(np.mod(x, np.pi), 0.) else np.sin(x) | [
"def",
"_sin",
"(",
"x",
")",
":",
"return",
"0.",
"if",
"np",
".",
"isclose",
"(",
"np",
".",
"mod",
"(",
"x",
",",
"np",
".",
"pi",
")",
",",
"0.",
")",
"else",
"np",
".",
"sin",
"(",
"x",
")"
] | sine with case for pi multiples | [
"sine",
"with",
"case",
"for",
"pi",
"multiples"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/geom/transform.py#L149-L151 | train | 235,474 |
BlueBrain/NeuroM | neurom/geom/transform.py | _rodrigues_to_dcm | def _rodrigues_to_dcm(axis, angle):
'''
Generates transformation matrix from unit vector
and rotation angle. The rotation is applied in the direction
of the axis which is a unit vector following the right hand rule.
Inputs :
axis : unit vector of the direction of the rotation
angle : angle of rotation in rads
Returns : 3x3 Rotation matrix
'''
ux, uy, uz = axis / np.linalg.norm(axis)
uxx = ux * ux
uyy = uy * uy
uzz = uz * uz
uxy = ux * uy
uxz = ux * uz
uyz = uy * uz
sn = _sin(angle)
cs = _sin(np.pi / 2. - angle)
cs1 = 1. - cs
R = np.zeros([3, 3])
R[0, 0] = cs + uxx * cs1
R[0, 1] = uxy * cs1 - uz * sn
R[0, 2] = uxz * cs1 + uy * sn
R[1, 0] = uxy * cs1 + uz * sn
R[1, 1] = cs + uyy * cs1
R[1, 2] = uyz * cs1 - ux * sn
R[2, 0] = uxz * cs1 - uy * sn
R[2, 1] = uyz * cs1 + ux * sn
R[2, 2] = cs + uzz * cs1
return R | python | def _rodrigues_to_dcm(axis, angle):
'''
Generates transformation matrix from unit vector
and rotation angle. The rotation is applied in the direction
of the axis which is a unit vector following the right hand rule.
Inputs :
axis : unit vector of the direction of the rotation
angle : angle of rotation in rads
Returns : 3x3 Rotation matrix
'''
ux, uy, uz = axis / np.linalg.norm(axis)
uxx = ux * ux
uyy = uy * uy
uzz = uz * uz
uxy = ux * uy
uxz = ux * uz
uyz = uy * uz
sn = _sin(angle)
cs = _sin(np.pi / 2. - angle)
cs1 = 1. - cs
R = np.zeros([3, 3])
R[0, 0] = cs + uxx * cs1
R[0, 1] = uxy * cs1 - uz * sn
R[0, 2] = uxz * cs1 + uy * sn
R[1, 0] = uxy * cs1 + uz * sn
R[1, 1] = cs + uyy * cs1
R[1, 2] = uyz * cs1 - ux * sn
R[2, 0] = uxz * cs1 - uy * sn
R[2, 1] = uyz * cs1 + ux * sn
R[2, 2] = cs + uzz * cs1
return R | [
"def",
"_rodrigues_to_dcm",
"(",
"axis",
",",
"angle",
")",
":",
"ux",
",",
"uy",
",",
"uz",
"=",
"axis",
"/",
"np",
".",
"linalg",
".",
"norm",
"(",
"axis",
")",
"uxx",
"=",
"ux",
"*",
"ux",
"uyy",
"=",
"uy",
"*",
"uy",
"uzz",
"=",
"uz",
"*",
"uz",
"uxy",
"=",
"ux",
"*",
"uy",
"uxz",
"=",
"ux",
"*",
"uz",
"uyz",
"=",
"uy",
"*",
"uz",
"sn",
"=",
"_sin",
"(",
"angle",
")",
"cs",
"=",
"_sin",
"(",
"np",
".",
"pi",
"/",
"2.",
"-",
"angle",
")",
"cs1",
"=",
"1.",
"-",
"cs",
"R",
"=",
"np",
".",
"zeros",
"(",
"[",
"3",
",",
"3",
"]",
")",
"R",
"[",
"0",
",",
"0",
"]",
"=",
"cs",
"+",
"uxx",
"*",
"cs1",
"R",
"[",
"0",
",",
"1",
"]",
"=",
"uxy",
"*",
"cs1",
"-",
"uz",
"*",
"sn",
"R",
"[",
"0",
",",
"2",
"]",
"=",
"uxz",
"*",
"cs1",
"+",
"uy",
"*",
"sn",
"R",
"[",
"1",
",",
"0",
"]",
"=",
"uxy",
"*",
"cs1",
"+",
"uz",
"*",
"sn",
"R",
"[",
"1",
",",
"1",
"]",
"=",
"cs",
"+",
"uyy",
"*",
"cs1",
"R",
"[",
"1",
",",
"2",
"]",
"=",
"uyz",
"*",
"cs1",
"-",
"ux",
"*",
"sn",
"R",
"[",
"2",
",",
"0",
"]",
"=",
"uxz",
"*",
"cs1",
"-",
"uy",
"*",
"sn",
"R",
"[",
"2",
",",
"1",
"]",
"=",
"uyz",
"*",
"cs1",
"+",
"ux",
"*",
"sn",
"R",
"[",
"2",
",",
"2",
"]",
"=",
"cs",
"+",
"uzz",
"*",
"cs1",
"return",
"R"
] | Generates transformation matrix from unit vector
and rotation angle. The rotation is applied in the direction
of the axis which is a unit vector following the right hand rule.
Inputs :
axis : unit vector of the direction of the rotation
angle : angle of rotation in rads
Returns : 3x3 Rotation matrix | [
"Generates",
"transformation",
"matrix",
"from",
"unit",
"vector",
"and",
"rotation",
"angle",
".",
"The",
"rotation",
"is",
"applied",
"in",
"the",
"direction",
"of",
"the",
"axis",
"which",
"is",
"a",
"unit",
"vector",
"following",
"the",
"right",
"hand",
"rule",
"."
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/geom/transform.py#L154-L194 | train | 235,475 |
BlueBrain/NeuroM | neurom/fst/_neuritefunc.py | total_length | def total_length(nrn_pop, neurite_type=NeuriteType.all):
'''Get the total length of all sections in the group of neurons or neurites'''
nrns = _neuronfunc.neuron_population(nrn_pop)
return list(sum(section_lengths(n, neurite_type=neurite_type)) for n in nrns) | python | def total_length(nrn_pop, neurite_type=NeuriteType.all):
'''Get the total length of all sections in the group of neurons or neurites'''
nrns = _neuronfunc.neuron_population(nrn_pop)
return list(sum(section_lengths(n, neurite_type=neurite_type)) for n in nrns) | [
"def",
"total_length",
"(",
"nrn_pop",
",",
"neurite_type",
"=",
"NeuriteType",
".",
"all",
")",
":",
"nrns",
"=",
"_neuronfunc",
".",
"neuron_population",
"(",
"nrn_pop",
")",
"return",
"list",
"(",
"sum",
"(",
"section_lengths",
"(",
"n",
",",
"neurite_type",
"=",
"neurite_type",
")",
")",
"for",
"n",
"in",
"nrns",
")"
] | Get the total length of all sections in the group of neurons or neurites | [
"Get",
"the",
"total",
"length",
"of",
"all",
"sections",
"in",
"the",
"group",
"of",
"neurons",
"or",
"neurites"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/fst/_neuritefunc.py#L45-L48 | train | 235,476 |
BlueBrain/NeuroM | neurom/fst/_neuritefunc.py | n_segments | def n_segments(neurites, neurite_type=NeuriteType.all):
'''Number of segments in a collection of neurites'''
return sum(len(s.points) - 1
for s in iter_sections(neurites, neurite_filter=is_type(neurite_type))) | python | def n_segments(neurites, neurite_type=NeuriteType.all):
'''Number of segments in a collection of neurites'''
return sum(len(s.points) - 1
for s in iter_sections(neurites, neurite_filter=is_type(neurite_type))) | [
"def",
"n_segments",
"(",
"neurites",
",",
"neurite_type",
"=",
"NeuriteType",
".",
"all",
")",
":",
"return",
"sum",
"(",
"len",
"(",
"s",
".",
"points",
")",
"-",
"1",
"for",
"s",
"in",
"iter_sections",
"(",
"neurites",
",",
"neurite_filter",
"=",
"is_type",
"(",
"neurite_type",
")",
")",
")"
] | Number of segments in a collection of neurites | [
"Number",
"of",
"segments",
"in",
"a",
"collection",
"of",
"neurites"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/fst/_neuritefunc.py#L51-L54 | train | 235,477 |
BlueBrain/NeuroM | neurom/fst/_neuritefunc.py | n_neurites | def n_neurites(neurites, neurite_type=NeuriteType.all):
'''Number of neurites in a collection of neurites'''
return sum(1 for _ in iter_neurites(neurites, filt=is_type(neurite_type))) | python | def n_neurites(neurites, neurite_type=NeuriteType.all):
'''Number of neurites in a collection of neurites'''
return sum(1 for _ in iter_neurites(neurites, filt=is_type(neurite_type))) | [
"def",
"n_neurites",
"(",
"neurites",
",",
"neurite_type",
"=",
"NeuriteType",
".",
"all",
")",
":",
"return",
"sum",
"(",
"1",
"for",
"_",
"in",
"iter_neurites",
"(",
"neurites",
",",
"filt",
"=",
"is_type",
"(",
"neurite_type",
")",
")",
")"
] | Number of neurites in a collection of neurites | [
"Number",
"of",
"neurites",
"in",
"a",
"collection",
"of",
"neurites"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/fst/_neuritefunc.py#L57-L59 | train | 235,478 |
BlueBrain/NeuroM | neurom/fst/_neuritefunc.py | n_sections | def n_sections(neurites, neurite_type=NeuriteType.all, iterator_type=Tree.ipreorder):
'''Number of sections in a collection of neurites'''
return sum(1 for _ in iter_sections(neurites,
iterator_type=iterator_type,
neurite_filter=is_type(neurite_type))) | python | def n_sections(neurites, neurite_type=NeuriteType.all, iterator_type=Tree.ipreorder):
'''Number of sections in a collection of neurites'''
return sum(1 for _ in iter_sections(neurites,
iterator_type=iterator_type,
neurite_filter=is_type(neurite_type))) | [
"def",
"n_sections",
"(",
"neurites",
",",
"neurite_type",
"=",
"NeuriteType",
".",
"all",
",",
"iterator_type",
"=",
"Tree",
".",
"ipreorder",
")",
":",
"return",
"sum",
"(",
"1",
"for",
"_",
"in",
"iter_sections",
"(",
"neurites",
",",
"iterator_type",
"=",
"iterator_type",
",",
"neurite_filter",
"=",
"is_type",
"(",
"neurite_type",
")",
")",
")"
] | Number of sections in a collection of neurites | [
"Number",
"of",
"sections",
"in",
"a",
"collection",
"of",
"neurites"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/fst/_neuritefunc.py#L62-L66 | train | 235,479 |
BlueBrain/NeuroM | neurom/fst/_neuritefunc.py | n_bifurcation_points | def n_bifurcation_points(neurites, neurite_type=NeuriteType.all):
'''number of bifurcation points in a collection of neurites'''
return n_sections(neurites, neurite_type=neurite_type, iterator_type=Tree.ibifurcation_point) | python | def n_bifurcation_points(neurites, neurite_type=NeuriteType.all):
'''number of bifurcation points in a collection of neurites'''
return n_sections(neurites, neurite_type=neurite_type, iterator_type=Tree.ibifurcation_point) | [
"def",
"n_bifurcation_points",
"(",
"neurites",
",",
"neurite_type",
"=",
"NeuriteType",
".",
"all",
")",
":",
"return",
"n_sections",
"(",
"neurites",
",",
"neurite_type",
"=",
"neurite_type",
",",
"iterator_type",
"=",
"Tree",
".",
"ibifurcation_point",
")"
] | number of bifurcation points in a collection of neurites | [
"number",
"of",
"bifurcation",
"points",
"in",
"a",
"collection",
"of",
"neurites"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/fst/_neuritefunc.py#L69-L71 | train | 235,480 |
BlueBrain/NeuroM | neurom/fst/_neuritefunc.py | n_forking_points | def n_forking_points(neurites, neurite_type=NeuriteType.all):
'''number of forking points in a collection of neurites'''
return n_sections(neurites, neurite_type=neurite_type, iterator_type=Tree.iforking_point) | python | def n_forking_points(neurites, neurite_type=NeuriteType.all):
'''number of forking points in a collection of neurites'''
return n_sections(neurites, neurite_type=neurite_type, iterator_type=Tree.iforking_point) | [
"def",
"n_forking_points",
"(",
"neurites",
",",
"neurite_type",
"=",
"NeuriteType",
".",
"all",
")",
":",
"return",
"n_sections",
"(",
"neurites",
",",
"neurite_type",
"=",
"neurite_type",
",",
"iterator_type",
"=",
"Tree",
".",
"iforking_point",
")"
] | number of forking points in a collection of neurites | [
"number",
"of",
"forking",
"points",
"in",
"a",
"collection",
"of",
"neurites"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/fst/_neuritefunc.py#L74-L76 | train | 235,481 |
BlueBrain/NeuroM | neurom/fst/_neuritefunc.py | n_leaves | def n_leaves(neurites, neurite_type=NeuriteType.all):
'''number of leaves points in a collection of neurites'''
return n_sections(neurites, neurite_type=neurite_type, iterator_type=Tree.ileaf) | python | def n_leaves(neurites, neurite_type=NeuriteType.all):
'''number of leaves points in a collection of neurites'''
return n_sections(neurites, neurite_type=neurite_type, iterator_type=Tree.ileaf) | [
"def",
"n_leaves",
"(",
"neurites",
",",
"neurite_type",
"=",
"NeuriteType",
".",
"all",
")",
":",
"return",
"n_sections",
"(",
"neurites",
",",
"neurite_type",
"=",
"neurite_type",
",",
"iterator_type",
"=",
"Tree",
".",
"ileaf",
")"
] | number of leaves points in a collection of neurites | [
"number",
"of",
"leaves",
"points",
"in",
"a",
"collection",
"of",
"neurites"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/fst/_neuritefunc.py#L79-L81 | train | 235,482 |
BlueBrain/NeuroM | neurom/fst/_neuritefunc.py | total_area_per_neurite | def total_area_per_neurite(neurites, neurite_type=NeuriteType.all):
'''Surface area in a collection of neurites.
The area is defined as the sum of the area of the sections.
'''
return [neurite.area for neurite in iter_neurites(neurites, filt=is_type(neurite_type))] | python | def total_area_per_neurite(neurites, neurite_type=NeuriteType.all):
'''Surface area in a collection of neurites.
The area is defined as the sum of the area of the sections.
'''
return [neurite.area for neurite in iter_neurites(neurites, filt=is_type(neurite_type))] | [
"def",
"total_area_per_neurite",
"(",
"neurites",
",",
"neurite_type",
"=",
"NeuriteType",
".",
"all",
")",
":",
"return",
"[",
"neurite",
".",
"area",
"for",
"neurite",
"in",
"iter_neurites",
"(",
"neurites",
",",
"filt",
"=",
"is_type",
"(",
"neurite_type",
")",
")",
"]"
] | Surface area in a collection of neurites.
The area is defined as the sum of the area of the sections. | [
"Surface",
"area",
"in",
"a",
"collection",
"of",
"neurites",
"."
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/fst/_neuritefunc.py#L84-L89 | train | 235,483 |
BlueBrain/NeuroM | neurom/fst/_neuritefunc.py | map_sections | def map_sections(fun, neurites, neurite_type=NeuriteType.all, iterator_type=Tree.ipreorder):
'''Map `fun` to all the sections in a collection of neurites'''
return map(fun, iter_sections(neurites,
iterator_type=iterator_type,
neurite_filter=is_type(neurite_type))) | python | def map_sections(fun, neurites, neurite_type=NeuriteType.all, iterator_type=Tree.ipreorder):
'''Map `fun` to all the sections in a collection of neurites'''
return map(fun, iter_sections(neurites,
iterator_type=iterator_type,
neurite_filter=is_type(neurite_type))) | [
"def",
"map_sections",
"(",
"fun",
",",
"neurites",
",",
"neurite_type",
"=",
"NeuriteType",
".",
"all",
",",
"iterator_type",
"=",
"Tree",
".",
"ipreorder",
")",
":",
"return",
"map",
"(",
"fun",
",",
"iter_sections",
"(",
"neurites",
",",
"iterator_type",
"=",
"iterator_type",
",",
"neurite_filter",
"=",
"is_type",
"(",
"neurite_type",
")",
")",
")"
] | Map `fun` to all the sections in a collection of neurites | [
"Map",
"fun",
"to",
"all",
"the",
"sections",
"in",
"a",
"collection",
"of",
"neurites"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/fst/_neuritefunc.py#L92-L96 | train | 235,484 |
BlueBrain/NeuroM | neurom/fst/_neuritefunc.py | section_lengths | def section_lengths(neurites, neurite_type=NeuriteType.all):
'''section lengths in a collection of neurites'''
return map_sections(_section_length, neurites, neurite_type=neurite_type) | python | def section_lengths(neurites, neurite_type=NeuriteType.all):
'''section lengths in a collection of neurites'''
return map_sections(_section_length, neurites, neurite_type=neurite_type) | [
"def",
"section_lengths",
"(",
"neurites",
",",
"neurite_type",
"=",
"NeuriteType",
".",
"all",
")",
":",
"return",
"map_sections",
"(",
"_section_length",
",",
"neurites",
",",
"neurite_type",
"=",
"neurite_type",
")"
] | section lengths in a collection of neurites | [
"section",
"lengths",
"in",
"a",
"collection",
"of",
"neurites"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/fst/_neuritefunc.py#L104-L106 | train | 235,485 |
BlueBrain/NeuroM | neurom/fst/_neuritefunc.py | section_term_lengths | def section_term_lengths(neurites, neurite_type=NeuriteType.all):
'''Termination section lengths in a collection of neurites'''
return map_sections(_section_length, neurites, neurite_type=neurite_type,
iterator_type=Tree.ileaf) | python | def section_term_lengths(neurites, neurite_type=NeuriteType.all):
'''Termination section lengths in a collection of neurites'''
return map_sections(_section_length, neurites, neurite_type=neurite_type,
iterator_type=Tree.ileaf) | [
"def",
"section_term_lengths",
"(",
"neurites",
",",
"neurite_type",
"=",
"NeuriteType",
".",
"all",
")",
":",
"return",
"map_sections",
"(",
"_section_length",
",",
"neurites",
",",
"neurite_type",
"=",
"neurite_type",
",",
"iterator_type",
"=",
"Tree",
".",
"ileaf",
")"
] | Termination section lengths in a collection of neurites | [
"Termination",
"section",
"lengths",
"in",
"a",
"collection",
"of",
"neurites"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/fst/_neuritefunc.py#L109-L112 | train | 235,486 |
BlueBrain/NeuroM | neurom/fst/_neuritefunc.py | section_bif_lengths | def section_bif_lengths(neurites, neurite_type=NeuriteType.all):
'''Bifurcation section lengths in a collection of neurites'''
return map_sections(_section_length, neurites, neurite_type=neurite_type,
iterator_type=Tree.ibifurcation_point) | python | def section_bif_lengths(neurites, neurite_type=NeuriteType.all):
'''Bifurcation section lengths in a collection of neurites'''
return map_sections(_section_length, neurites, neurite_type=neurite_type,
iterator_type=Tree.ibifurcation_point) | [
"def",
"section_bif_lengths",
"(",
"neurites",
",",
"neurite_type",
"=",
"NeuriteType",
".",
"all",
")",
":",
"return",
"map_sections",
"(",
"_section_length",
",",
"neurites",
",",
"neurite_type",
"=",
"neurite_type",
",",
"iterator_type",
"=",
"Tree",
".",
"ibifurcation_point",
")"
] | Bifurcation section lengths in a collection of neurites | [
"Bifurcation",
"section",
"lengths",
"in",
"a",
"collection",
"of",
"neurites"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/fst/_neuritefunc.py#L115-L118 | train | 235,487 |
BlueBrain/NeuroM | neurom/fst/_neuritefunc.py | section_branch_orders | def section_branch_orders(neurites, neurite_type=NeuriteType.all):
'''section branch orders in a collection of neurites'''
return map_sections(sectionfunc.branch_order, neurites, neurite_type=neurite_type) | python | def section_branch_orders(neurites, neurite_type=NeuriteType.all):
'''section branch orders in a collection of neurites'''
return map_sections(sectionfunc.branch_order, neurites, neurite_type=neurite_type) | [
"def",
"section_branch_orders",
"(",
"neurites",
",",
"neurite_type",
"=",
"NeuriteType",
".",
"all",
")",
":",
"return",
"map_sections",
"(",
"sectionfunc",
".",
"branch_order",
",",
"neurites",
",",
"neurite_type",
"=",
"neurite_type",
")"
] | section branch orders in a collection of neurites | [
"section",
"branch",
"orders",
"in",
"a",
"collection",
"of",
"neurites"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/fst/_neuritefunc.py#L121-L123 | train | 235,488 |
BlueBrain/NeuroM | neurom/fst/_neuritefunc.py | section_bif_branch_orders | def section_bif_branch_orders(neurites, neurite_type=NeuriteType.all):
'''Bifurcation section branch orders in a collection of neurites'''
return map_sections(sectionfunc.branch_order, neurites, neurite_type=neurite_type,
iterator_type=Tree.ibifurcation_point) | python | def section_bif_branch_orders(neurites, neurite_type=NeuriteType.all):
'''Bifurcation section branch orders in a collection of neurites'''
return map_sections(sectionfunc.branch_order, neurites, neurite_type=neurite_type,
iterator_type=Tree.ibifurcation_point) | [
"def",
"section_bif_branch_orders",
"(",
"neurites",
",",
"neurite_type",
"=",
"NeuriteType",
".",
"all",
")",
":",
"return",
"map_sections",
"(",
"sectionfunc",
".",
"branch_order",
",",
"neurites",
",",
"neurite_type",
"=",
"neurite_type",
",",
"iterator_type",
"=",
"Tree",
".",
"ibifurcation_point",
")"
] | Bifurcation section branch orders in a collection of neurites | [
"Bifurcation",
"section",
"branch",
"orders",
"in",
"a",
"collection",
"of",
"neurites"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/fst/_neuritefunc.py#L126-L129 | train | 235,489 |
BlueBrain/NeuroM | neurom/fst/_neuritefunc.py | section_term_branch_orders | def section_term_branch_orders(neurites, neurite_type=NeuriteType.all):
'''Termination section branch orders in a collection of neurites'''
return map_sections(sectionfunc.branch_order, neurites, neurite_type=neurite_type,
iterator_type=Tree.ileaf) | python | def section_term_branch_orders(neurites, neurite_type=NeuriteType.all):
'''Termination section branch orders in a collection of neurites'''
return map_sections(sectionfunc.branch_order, neurites, neurite_type=neurite_type,
iterator_type=Tree.ileaf) | [
"def",
"section_term_branch_orders",
"(",
"neurites",
",",
"neurite_type",
"=",
"NeuriteType",
".",
"all",
")",
":",
"return",
"map_sections",
"(",
"sectionfunc",
".",
"branch_order",
",",
"neurites",
",",
"neurite_type",
"=",
"neurite_type",
",",
"iterator_type",
"=",
"Tree",
".",
"ileaf",
")"
] | Termination section branch orders in a collection of neurites | [
"Termination",
"section",
"branch",
"orders",
"in",
"a",
"collection",
"of",
"neurites"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/fst/_neuritefunc.py#L132-L135 | train | 235,490 |
BlueBrain/NeuroM | neurom/fst/_neuritefunc.py | section_path_lengths | def section_path_lengths(neurites, neurite_type=NeuriteType.all):
'''Path lengths of a collection of neurites '''
# Calculates and stores the section lengths in one pass,
# then queries the lengths in the path length iterations.
# This avoids repeatedly calculating the lengths of the
# same sections.
dist = {}
neurite_filter = is_type(neurite_type)
for s in iter_sections(neurites, neurite_filter=neurite_filter):
dist[s] = s.length
def pl2(node):
'''Calculate the path length using cached section lengths'''
return sum(dist[n] for n in node.iupstream())
return map_sections(pl2, neurites, neurite_type=neurite_type) | python | def section_path_lengths(neurites, neurite_type=NeuriteType.all):
'''Path lengths of a collection of neurites '''
# Calculates and stores the section lengths in one pass,
# then queries the lengths in the path length iterations.
# This avoids repeatedly calculating the lengths of the
# same sections.
dist = {}
neurite_filter = is_type(neurite_type)
for s in iter_sections(neurites, neurite_filter=neurite_filter):
dist[s] = s.length
def pl2(node):
'''Calculate the path length using cached section lengths'''
return sum(dist[n] for n in node.iupstream())
return map_sections(pl2, neurites, neurite_type=neurite_type) | [
"def",
"section_path_lengths",
"(",
"neurites",
",",
"neurite_type",
"=",
"NeuriteType",
".",
"all",
")",
":",
"# Calculates and stores the section lengths in one pass,",
"# then queries the lengths in the path length iterations.",
"# This avoids repeatedly calculating the lengths of the",
"# same sections.",
"dist",
"=",
"{",
"}",
"neurite_filter",
"=",
"is_type",
"(",
"neurite_type",
")",
"for",
"s",
"in",
"iter_sections",
"(",
"neurites",
",",
"neurite_filter",
"=",
"neurite_filter",
")",
":",
"dist",
"[",
"s",
"]",
"=",
"s",
".",
"length",
"def",
"pl2",
"(",
"node",
")",
":",
"'''Calculate the path length using cached section lengths'''",
"return",
"sum",
"(",
"dist",
"[",
"n",
"]",
"for",
"n",
"in",
"node",
".",
"iupstream",
"(",
")",
")",
"return",
"map_sections",
"(",
"pl2",
",",
"neurites",
",",
"neurite_type",
"=",
"neurite_type",
")"
] | Path lengths of a collection of neurites | [
"Path",
"lengths",
"of",
"a",
"collection",
"of",
"neurites"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/fst/_neuritefunc.py#L138-L154 | train | 235,491 |
BlueBrain/NeuroM | neurom/fst/_neuritefunc.py | map_neurons | def map_neurons(fun, neurites, neurite_type):
'''Map `fun` to all the neurites in a single or collection of neurons'''
nrns = _neuronfunc.neuron_population(neurites)
return [fun(n, neurite_type=neurite_type) for n in nrns] | python | def map_neurons(fun, neurites, neurite_type):
'''Map `fun` to all the neurites in a single or collection of neurons'''
nrns = _neuronfunc.neuron_population(neurites)
return [fun(n, neurite_type=neurite_type) for n in nrns] | [
"def",
"map_neurons",
"(",
"fun",
",",
"neurites",
",",
"neurite_type",
")",
":",
"nrns",
"=",
"_neuronfunc",
".",
"neuron_population",
"(",
"neurites",
")",
"return",
"[",
"fun",
"(",
"n",
",",
"neurite_type",
"=",
"neurite_type",
")",
"for",
"n",
"in",
"nrns",
"]"
] | Map `fun` to all the neurites in a single or collection of neurons | [
"Map",
"fun",
"to",
"all",
"the",
"neurites",
"in",
"a",
"single",
"or",
"collection",
"of",
"neurons"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/fst/_neuritefunc.py#L157-L160 | train | 235,492 |
BlueBrain/NeuroM | neurom/fst/_neuritefunc.py | map_segments | def map_segments(func, neurites, neurite_type):
''' Map `func` to all the segments in a collection of neurites
`func` accepts a section and returns list of values corresponding to each segment.
'''
neurite_filter = is_type(neurite_type)
return [
s for ss in iter_sections(neurites, neurite_filter=neurite_filter) for s in func(ss)
] | python | def map_segments(func, neurites, neurite_type):
''' Map `func` to all the segments in a collection of neurites
`func` accepts a section and returns list of values corresponding to each segment.
'''
neurite_filter = is_type(neurite_type)
return [
s for ss in iter_sections(neurites, neurite_filter=neurite_filter) for s in func(ss)
] | [
"def",
"map_segments",
"(",
"func",
",",
"neurites",
",",
"neurite_type",
")",
":",
"neurite_filter",
"=",
"is_type",
"(",
"neurite_type",
")",
"return",
"[",
"s",
"for",
"ss",
"in",
"iter_sections",
"(",
"neurites",
",",
"neurite_filter",
"=",
"neurite_filter",
")",
"for",
"s",
"in",
"func",
"(",
"ss",
")",
"]"
] | Map `func` to all the segments in a collection of neurites
`func` accepts a section and returns list of values corresponding to each segment. | [
"Map",
"func",
"to",
"all",
"the",
"segments",
"in",
"a",
"collection",
"of",
"neurites"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/fst/_neuritefunc.py#L193-L201 | train | 235,493 |
BlueBrain/NeuroM | neurom/fst/_neuritefunc.py | segment_volumes | def segment_volumes(neurites, neurite_type=NeuriteType.all):
'''Volumes of the segments in a collection of neurites'''
def _func(sec):
'''list of segment volumes of a section'''
return [morphmath.segment_volume(seg) for seg in zip(sec.points[:-1], sec.points[1:])]
return map_segments(_func, neurites, neurite_type) | python | def segment_volumes(neurites, neurite_type=NeuriteType.all):
'''Volumes of the segments in a collection of neurites'''
def _func(sec):
'''list of segment volumes of a section'''
return [morphmath.segment_volume(seg) for seg in zip(sec.points[:-1], sec.points[1:])]
return map_segments(_func, neurites, neurite_type) | [
"def",
"segment_volumes",
"(",
"neurites",
",",
"neurite_type",
"=",
"NeuriteType",
".",
"all",
")",
":",
"def",
"_func",
"(",
"sec",
")",
":",
"'''list of segment volumes of a section'''",
"return",
"[",
"morphmath",
".",
"segment_volume",
"(",
"seg",
")",
"for",
"seg",
"in",
"zip",
"(",
"sec",
".",
"points",
"[",
":",
"-",
"1",
"]",
",",
"sec",
".",
"points",
"[",
"1",
":",
"]",
")",
"]",
"return",
"map_segments",
"(",
"_func",
",",
"neurites",
",",
"neurite_type",
")"
] | Volumes of the segments in a collection of neurites | [
"Volumes",
"of",
"the",
"segments",
"in",
"a",
"collection",
"of",
"neurites"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/fst/_neuritefunc.py#L213-L219 | train | 235,494 |
BlueBrain/NeuroM | neurom/fst/_neuritefunc.py | segment_radii | def segment_radii(neurites, neurite_type=NeuriteType.all):
'''arithmetic mean of the radii of the points in segments in a collection of neurites'''
def _seg_radii(sec):
'''vectorized mean radii'''
pts = sec.points[:, COLS.R]
return np.divide(np.add(pts[:-1], pts[1:]), 2.0)
return map_segments(_seg_radii, neurites, neurite_type) | python | def segment_radii(neurites, neurite_type=NeuriteType.all):
'''arithmetic mean of the radii of the points in segments in a collection of neurites'''
def _seg_radii(sec):
'''vectorized mean radii'''
pts = sec.points[:, COLS.R]
return np.divide(np.add(pts[:-1], pts[1:]), 2.0)
return map_segments(_seg_radii, neurites, neurite_type) | [
"def",
"segment_radii",
"(",
"neurites",
",",
"neurite_type",
"=",
"NeuriteType",
".",
"all",
")",
":",
"def",
"_seg_radii",
"(",
"sec",
")",
":",
"'''vectorized mean radii'''",
"pts",
"=",
"sec",
".",
"points",
"[",
":",
",",
"COLS",
".",
"R",
"]",
"return",
"np",
".",
"divide",
"(",
"np",
".",
"add",
"(",
"pts",
"[",
":",
"-",
"1",
"]",
",",
"pts",
"[",
"1",
":",
"]",
")",
",",
"2.0",
")",
"return",
"map_segments",
"(",
"_seg_radii",
",",
"neurites",
",",
"neurite_type",
")"
] | arithmetic mean of the radii of the points in segments in a collection of neurites | [
"arithmetic",
"mean",
"of",
"the",
"radii",
"of",
"the",
"points",
"in",
"segments",
"in",
"a",
"collection",
"of",
"neurites"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/fst/_neuritefunc.py#L222-L229 | train | 235,495 |
BlueBrain/NeuroM | neurom/fst/_neuritefunc.py | segment_taper_rates | def segment_taper_rates(neurites, neurite_type=NeuriteType.all):
'''taper rates of the segments in a collection of neurites
The taper rate is defined as the absolute radii differences divided by length of the section
'''
def _seg_taper_rates(sec):
'''vectorized taper rates'''
pts = sec.points[:, COLS.XYZR]
diff = np.diff(pts, axis=0)
distance = np.linalg.norm(diff[:, COLS.XYZ], axis=1)
return np.divide(2 * np.abs(diff[:, COLS.R]), distance)
return map_segments(_seg_taper_rates, neurites, neurite_type) | python | def segment_taper_rates(neurites, neurite_type=NeuriteType.all):
'''taper rates of the segments in a collection of neurites
The taper rate is defined as the absolute radii differences divided by length of the section
'''
def _seg_taper_rates(sec):
'''vectorized taper rates'''
pts = sec.points[:, COLS.XYZR]
diff = np.diff(pts, axis=0)
distance = np.linalg.norm(diff[:, COLS.XYZ], axis=1)
return np.divide(2 * np.abs(diff[:, COLS.R]), distance)
return map_segments(_seg_taper_rates, neurites, neurite_type) | [
"def",
"segment_taper_rates",
"(",
"neurites",
",",
"neurite_type",
"=",
"NeuriteType",
".",
"all",
")",
":",
"def",
"_seg_taper_rates",
"(",
"sec",
")",
":",
"'''vectorized taper rates'''",
"pts",
"=",
"sec",
".",
"points",
"[",
":",
",",
"COLS",
".",
"XYZR",
"]",
"diff",
"=",
"np",
".",
"diff",
"(",
"pts",
",",
"axis",
"=",
"0",
")",
"distance",
"=",
"np",
".",
"linalg",
".",
"norm",
"(",
"diff",
"[",
":",
",",
"COLS",
".",
"XYZ",
"]",
",",
"axis",
"=",
"1",
")",
"return",
"np",
".",
"divide",
"(",
"2",
"*",
"np",
".",
"abs",
"(",
"diff",
"[",
":",
",",
"COLS",
".",
"R",
"]",
")",
",",
"distance",
")",
"return",
"map_segments",
"(",
"_seg_taper_rates",
",",
"neurites",
",",
"neurite_type",
")"
] | taper rates of the segments in a collection of neurites
The taper rate is defined as the absolute radii differences divided by length of the section | [
"taper",
"rates",
"of",
"the",
"segments",
"in",
"a",
"collection",
"of",
"neurites"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/fst/_neuritefunc.py#L232-L244 | train | 235,496 |
BlueBrain/NeuroM | neurom/fst/_neuritefunc.py | segment_midpoints | def segment_midpoints(neurites, neurite_type=NeuriteType.all):
'''Return a list of segment mid-points in a collection of neurites'''
def _seg_midpoint(sec):
'''Return the mid-points of segments in a section'''
pts = sec.points[:, COLS.XYZ]
return np.divide(np.add(pts[:-1], pts[1:]), 2.0)
return map_segments(_seg_midpoint, neurites, neurite_type) | python | def segment_midpoints(neurites, neurite_type=NeuriteType.all):
'''Return a list of segment mid-points in a collection of neurites'''
def _seg_midpoint(sec):
'''Return the mid-points of segments in a section'''
pts = sec.points[:, COLS.XYZ]
return np.divide(np.add(pts[:-1], pts[1:]), 2.0)
return map_segments(_seg_midpoint, neurites, neurite_type) | [
"def",
"segment_midpoints",
"(",
"neurites",
",",
"neurite_type",
"=",
"NeuriteType",
".",
"all",
")",
":",
"def",
"_seg_midpoint",
"(",
"sec",
")",
":",
"'''Return the mid-points of segments in a section'''",
"pts",
"=",
"sec",
".",
"points",
"[",
":",
",",
"COLS",
".",
"XYZ",
"]",
"return",
"np",
".",
"divide",
"(",
"np",
".",
"add",
"(",
"pts",
"[",
":",
"-",
"1",
"]",
",",
"pts",
"[",
"1",
":",
"]",
")",
",",
"2.0",
")",
"return",
"map_segments",
"(",
"_seg_midpoint",
",",
"neurites",
",",
"neurite_type",
")"
] | Return a list of segment mid-points in a collection of neurites | [
"Return",
"a",
"list",
"of",
"segment",
"mid",
"-",
"points",
"in",
"a",
"collection",
"of",
"neurites"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/fst/_neuritefunc.py#L253-L260 | train | 235,497 |
BlueBrain/NeuroM | neurom/fst/_neuritefunc.py | local_bifurcation_angles | def local_bifurcation_angles(neurites, neurite_type=NeuriteType.all):
'''Get a list of local bifurcation angles in a collection of neurites'''
return map_sections(_bifurcationfunc.local_bifurcation_angle,
neurites,
neurite_type=neurite_type,
iterator_type=Tree.ibifurcation_point) | python | def local_bifurcation_angles(neurites, neurite_type=NeuriteType.all):
'''Get a list of local bifurcation angles in a collection of neurites'''
return map_sections(_bifurcationfunc.local_bifurcation_angle,
neurites,
neurite_type=neurite_type,
iterator_type=Tree.ibifurcation_point) | [
"def",
"local_bifurcation_angles",
"(",
"neurites",
",",
"neurite_type",
"=",
"NeuriteType",
".",
"all",
")",
":",
"return",
"map_sections",
"(",
"_bifurcationfunc",
".",
"local_bifurcation_angle",
",",
"neurites",
",",
"neurite_type",
"=",
"neurite_type",
",",
"iterator_type",
"=",
"Tree",
".",
"ibifurcation_point",
")"
] | Get a list of local bifurcation angles in a collection of neurites | [
"Get",
"a",
"list",
"of",
"local",
"bifurcation",
"angles",
"in",
"a",
"collection",
"of",
"neurites"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/fst/_neuritefunc.py#L280-L285 | train | 235,498 |
BlueBrain/NeuroM | neurom/fst/_neuritefunc.py | remote_bifurcation_angles | def remote_bifurcation_angles(neurites, neurite_type=NeuriteType.all):
'''Get a list of remote bifurcation angles in a collection of neurites'''
return map_sections(_bifurcationfunc.remote_bifurcation_angle,
neurites,
neurite_type=neurite_type,
iterator_type=Tree.ibifurcation_point) | python | def remote_bifurcation_angles(neurites, neurite_type=NeuriteType.all):
'''Get a list of remote bifurcation angles in a collection of neurites'''
return map_sections(_bifurcationfunc.remote_bifurcation_angle,
neurites,
neurite_type=neurite_type,
iterator_type=Tree.ibifurcation_point) | [
"def",
"remote_bifurcation_angles",
"(",
"neurites",
",",
"neurite_type",
"=",
"NeuriteType",
".",
"all",
")",
":",
"return",
"map_sections",
"(",
"_bifurcationfunc",
".",
"remote_bifurcation_angle",
",",
"neurites",
",",
"neurite_type",
"=",
"neurite_type",
",",
"iterator_type",
"=",
"Tree",
".",
"ibifurcation_point",
")"
] | Get a list of remote bifurcation angles in a collection of neurites | [
"Get",
"a",
"list",
"of",
"remote",
"bifurcation",
"angles",
"in",
"a",
"collection",
"of",
"neurites"
] | 254bb73535b20053d175bc4725bade662177d12b | https://github.com/BlueBrain/NeuroM/blob/254bb73535b20053d175bc4725bade662177d12b/neurom/fst/_neuritefunc.py#L288-L293 | train | 235,499 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.