body
stringlengths 26
98.2k
| body_hash
int64 -9,222,864,604,528,158,000
9,221,803,474B
| docstring
stringlengths 1
16.8k
| path
stringlengths 5
230
| name
stringlengths 1
96
| repository_name
stringlengths 7
89
| lang
stringclasses 1
value | body_without_docstring
stringlengths 20
98.2k
|
|---|---|---|---|---|---|---|---|
def __init__(self, l2_norm_clip, stddev):
'Initializes the GaussianSumQuery.\n\n Args:\n l2_norm_clip: The clipping norm to apply to the global norm of each\n record.\n stddev: The stddev of the noise added to the sum.\n '
self._l2_norm_clip = l2_norm_clip
self._stddev = stddev
self._ledger = None
| 830,702,645,456,667,900
|
Initializes the GaussianSumQuery.
Args:
l2_norm_clip: The clipping norm to apply to the global norm of each
record.
stddev: The stddev of the noise added to the sum.
|
tensorflow_privacy/privacy/dp_query/gaussian_query.py
|
__init__
|
Juspem1980/privacy
|
python
|
def __init__(self, l2_norm_clip, stddev):
'Initializes the GaussianSumQuery.\n\n Args:\n l2_norm_clip: The clipping norm to apply to the global norm of each\n record.\n stddev: The stddev of the noise added to the sum.\n '
self._l2_norm_clip = l2_norm_clip
self._stddev = stddev
self._ledger = None
|
def make_global_state(self, l2_norm_clip, stddev):
'Creates a global state from the given parameters.'
return self._GlobalState(tf.cast(l2_norm_clip, tf.float32), tf.cast(stddev, tf.float32))
| 7,631,861,765,875,769,000
|
Creates a global state from the given parameters.
|
tensorflow_privacy/privacy/dp_query/gaussian_query.py
|
make_global_state
|
Juspem1980/privacy
|
python
|
def make_global_state(self, l2_norm_clip, stddev):
return self._GlobalState(tf.cast(l2_norm_clip, tf.float32), tf.cast(stddev, tf.float32))
|
def preprocess_record_impl(self, params, record):
'Clips the l2 norm, returning the clipped record and the l2 norm.\n\n Args:\n params: The parameters for the sample.\n record: The record to be processed.\n\n Returns:\n A tuple (preprocessed_records, l2_norm) where `preprocessed_records` is\n the structure of preprocessed tensors, and l2_norm is the total l2 norm\n before clipping.\n '
l2_norm_clip = params
record_as_list = tf.nest.flatten(record)
(clipped_as_list, norm) = tf.clip_by_global_norm(record_as_list, l2_norm_clip)
return (tf.nest.pack_sequence_as(record, clipped_as_list), norm)
| -7,945,747,213,345,504,000
|
Clips the l2 norm, returning the clipped record and the l2 norm.
Args:
params: The parameters for the sample.
record: The record to be processed.
Returns:
A tuple (preprocessed_records, l2_norm) where `preprocessed_records` is
the structure of preprocessed tensors, and l2_norm is the total l2 norm
before clipping.
|
tensorflow_privacy/privacy/dp_query/gaussian_query.py
|
preprocess_record_impl
|
Juspem1980/privacy
|
python
|
def preprocess_record_impl(self, params, record):
'Clips the l2 norm, returning the clipped record and the l2 norm.\n\n Args:\n params: The parameters for the sample.\n record: The record to be processed.\n\n Returns:\n A tuple (preprocessed_records, l2_norm) where `preprocessed_records` is\n the structure of preprocessed tensors, and l2_norm is the total l2 norm\n before clipping.\n '
l2_norm_clip = params
record_as_list = tf.nest.flatten(record)
(clipped_as_list, norm) = tf.clip_by_global_norm(record_as_list, l2_norm_clip)
return (tf.nest.pack_sequence_as(record, clipped_as_list), norm)
|
def get_noised_result(self, sample_state, global_state):
'See base class.'
if (LooseVersion(tf.__version__) < LooseVersion('2.0.0')):
def add_noise(v):
return (v + tf.random.normal(tf.shape(input=v), stddev=global_state.stddev))
else:
random_normal = tf.random_normal_initializer(stddev=global_state.stddev)
def add_noise(v):
return (v + random_normal(tf.shape(input=v)))
if self._ledger:
dependencies = [self._ledger.record_sum_query(global_state.l2_norm_clip, global_state.stddev)]
else:
dependencies = []
with tf.control_dependencies(dependencies):
return (tf.nest.map_structure(add_noise, sample_state), global_state)
| -6,189,862,732,280,817,000
|
See base class.
|
tensorflow_privacy/privacy/dp_query/gaussian_query.py
|
get_noised_result
|
Juspem1980/privacy
|
python
|
def get_noised_result(self, sample_state, global_state):
if (LooseVersion(tf.__version__) < LooseVersion('2.0.0')):
def add_noise(v):
return (v + tf.random.normal(tf.shape(input=v), stddev=global_state.stddev))
else:
random_normal = tf.random_normal_initializer(stddev=global_state.stddev)
def add_noise(v):
return (v + random_normal(tf.shape(input=v)))
if self._ledger:
dependencies = [self._ledger.record_sum_query(global_state.l2_norm_clip, global_state.stddev)]
else:
dependencies = []
with tf.control_dependencies(dependencies):
return (tf.nest.map_structure(add_noise, sample_state), global_state)
|
def __init__(self, l2_norm_clip, sum_stddev, denominator):
'Initializes the GaussianAverageQuery.\n\n Args:\n l2_norm_clip: The clipping norm to apply to the global norm of each\n record.\n sum_stddev: The stddev of the noise added to the sum (before\n normalization).\n denominator: The normalization constant (applied after noise is added to\n the sum).\n '
super(GaussianAverageQuery, self).__init__(numerator_query=GaussianSumQuery(l2_norm_clip, sum_stddev), denominator=denominator)
| -4,537,654,262,657,255,000
|
Initializes the GaussianAverageQuery.
Args:
l2_norm_clip: The clipping norm to apply to the global norm of each
record.
sum_stddev: The stddev of the noise added to the sum (before
normalization).
denominator: The normalization constant (applied after noise is added to
the sum).
|
tensorflow_privacy/privacy/dp_query/gaussian_query.py
|
__init__
|
Juspem1980/privacy
|
python
|
def __init__(self, l2_norm_clip, sum_stddev, denominator):
'Initializes the GaussianAverageQuery.\n\n Args:\n l2_norm_clip: The clipping norm to apply to the global norm of each\n record.\n sum_stddev: The stddev of the noise added to the sum (before\n normalization).\n denominator: The normalization constant (applied after noise is added to\n the sum).\n '
super(GaussianAverageQuery, self).__init__(numerator_query=GaussianSumQuery(l2_norm_clip, sum_stddev), denominator=denominator)
|
def _assert_community_contribution_stats_is_in_default_state(self):
'Checks if the community contribution stats is in its default\n state.\n '
community_contribution_stats = suggestion_services.get_community_contribution_stats()
self.assertEqual(community_contribution_stats.translation_reviewer_counts_by_lang_code, {})
self.assertEqual(community_contribution_stats.translation_suggestion_counts_by_lang_code, {})
self.assertEqual(community_contribution_stats.question_reviewer_count, 0)
self.assertEqual(community_contribution_stats.question_suggestion_count, 0)
| -8,273,821,425,724,012,000
|
Checks if the community contribution stats is in its default
state.
|
core/domain/suggestion_registry_test.py
|
_assert_community_contribution_stats_is_in_default_state
|
AdityaDubey0/oppia
|
python
|
def _assert_community_contribution_stats_is_in_default_state(self):
'Checks if the community contribution stats is in its default\n state.\n '
community_contribution_stats = suggestion_services.get_community_contribution_stats()
self.assertEqual(community_contribution_stats.translation_reviewer_counts_by_lang_code, {})
self.assertEqual(community_contribution_stats.translation_suggestion_counts_by_lang_code, {})
self.assertEqual(community_contribution_stats.question_reviewer_count, 0)
self.assertEqual(community_contribution_stats.question_suggestion_count, 0)
|
def conversion_fn():
'Temporary function.'
pass
| -7,532,713,194,701,360,000
|
Temporary function.
|
core/domain/suggestion_registry_test.py
|
conversion_fn
|
AdityaDubey0/oppia
|
python
|
def conversion_fn():
pass
|
def __init__(self, feats_extract: Optional[AbsFeatsExtract], normalize: Optional[(AbsNormalize and InversibleInterface)], tts: AbsGANTTS):
'Initialize ESPnetGANTTSModel module.'
assert check_argument_types()
super().__init__()
self.feats_extract = feats_extract
self.normalize = normalize
self.tts = tts
assert hasattr(tts, 'generator'), 'generator module must be resistered as tts.generator'
assert hasattr(tts, 'discriminator'), 'discriminator module must be resistered as tts.discriminator'
| -4,964,261,881,008,749,000
|
Initialize ESPnetGANTTSModel module.
|
espnet2/gan_tts/espnet_model.py
|
__init__
|
actboy/espnet
|
python
|
def __init__(self, feats_extract: Optional[AbsFeatsExtract], normalize: Optional[(AbsNormalize and InversibleInterface)], tts: AbsGANTTS):
assert check_argument_types()
super().__init__()
self.feats_extract = feats_extract
self.normalize = normalize
self.tts = tts
assert hasattr(tts, 'generator'), 'generator module must be resistered as tts.generator'
assert hasattr(tts, 'discriminator'), 'discriminator module must be resistered as tts.discriminator'
|
def forward(self, text: torch.Tensor, text_lengths: torch.Tensor, speech: torch.Tensor, speech_lengths: torch.Tensor, spembs: Optional[torch.Tensor]=None, sids: Optional[torch.Tensor]=None, lids: Optional[torch.Tensor]=None, forward_generator: bool=True) -> Dict[(str, Any)]:
'Return generator or discriminator loss with dict format.\n\n Args:\n text (Tensor): Text index tensor (B, T_text).\n text_lengths (Tensor): Text length tensor (B,).\n speech (Tensor): Speech waveform tensor (B, T_wav).\n speech_lengths (Tensor): Speech length tensor (B,).\n spembs (Optional[Tensor]): Speaker embedding tensor (B, D).\n sids (Optional[Tensor]): Speaker ID tensor (B, 1).\n lids (Optional[Tensor]): Language ID tensor (B, 1).\n forward_generator (bool): Whether to forward generator.\n\n Returns:\n Dict[str, Any]:\n - loss (Tensor): Loss scalar tensor.\n - stats (Dict[str, float]): Statistics to be monitored.\n - weight (Tensor): Weight tensor to summarize losses.\n - optim_idx (int): Optimizer index (0 for G and 1 for D).\n\n '
with autocast(False):
feats = None
if (self.feats_extract is not None):
(feats, feats_lengths) = self.feats_extract(speech, speech_lengths)
if (self.normalize is not None):
(feats, feats_lengths) = self.normalize(feats, feats_lengths)
batch = {}
batch.update(text=text, text_lengths=text_lengths)
batch.update(forward_generator=forward_generator)
if (feats is not None):
batch.update(feats=feats, feats_lengths=feats_lengths)
if self.tts.require_raw_speech:
batch.update(speech=speech, speech_lengths=speech_lengths)
if (spembs is not None):
batch.update(spembs=spembs)
if (sids is not None):
batch.update(sids=sids)
if (lids is not None):
batch.update(lids=lids)
return self.tts(**batch)
| -8,931,493,892,899,705,000
|
Return generator or discriminator loss with dict format.
Args:
text (Tensor): Text index tensor (B, T_text).
text_lengths (Tensor): Text length tensor (B,).
speech (Tensor): Speech waveform tensor (B, T_wav).
speech_lengths (Tensor): Speech length tensor (B,).
spembs (Optional[Tensor]): Speaker embedding tensor (B, D).
sids (Optional[Tensor]): Speaker ID tensor (B, 1).
lids (Optional[Tensor]): Language ID tensor (B, 1).
forward_generator (bool): Whether to forward generator.
Returns:
Dict[str, Any]:
- loss (Tensor): Loss scalar tensor.
- stats (Dict[str, float]): Statistics to be monitored.
- weight (Tensor): Weight tensor to summarize losses.
- optim_idx (int): Optimizer index (0 for G and 1 for D).
|
espnet2/gan_tts/espnet_model.py
|
forward
|
actboy/espnet
|
python
|
def forward(self, text: torch.Tensor, text_lengths: torch.Tensor, speech: torch.Tensor, speech_lengths: torch.Tensor, spembs: Optional[torch.Tensor]=None, sids: Optional[torch.Tensor]=None, lids: Optional[torch.Tensor]=None, forward_generator: bool=True) -> Dict[(str, Any)]:
'Return generator or discriminator loss with dict format.\n\n Args:\n text (Tensor): Text index tensor (B, T_text).\n text_lengths (Tensor): Text length tensor (B,).\n speech (Tensor): Speech waveform tensor (B, T_wav).\n speech_lengths (Tensor): Speech length tensor (B,).\n spembs (Optional[Tensor]): Speaker embedding tensor (B, D).\n sids (Optional[Tensor]): Speaker ID tensor (B, 1).\n lids (Optional[Tensor]): Language ID tensor (B, 1).\n forward_generator (bool): Whether to forward generator.\n\n Returns:\n Dict[str, Any]:\n - loss (Tensor): Loss scalar tensor.\n - stats (Dict[str, float]): Statistics to be monitored.\n - weight (Tensor): Weight tensor to summarize losses.\n - optim_idx (int): Optimizer index (0 for G and 1 for D).\n\n '
with autocast(False):
feats = None
if (self.feats_extract is not None):
(feats, feats_lengths) = self.feats_extract(speech, speech_lengths)
if (self.normalize is not None):
(feats, feats_lengths) = self.normalize(feats, feats_lengths)
batch = {}
batch.update(text=text, text_lengths=text_lengths)
batch.update(forward_generator=forward_generator)
if (feats is not None):
batch.update(feats=feats, feats_lengths=feats_lengths)
if self.tts.require_raw_speech:
batch.update(speech=speech, speech_lengths=speech_lengths)
if (spembs is not None):
batch.update(spembs=spembs)
if (sids is not None):
batch.update(sids=sids)
if (lids is not None):
batch.update(lids=lids)
return self.tts(**batch)
|
def collect_feats(self, text: torch.Tensor, text_lengths: torch.Tensor, speech: torch.Tensor, speech_lengths: torch.Tensor, spembs: Optional[torch.Tensor]=None, sids: Optional[torch.Tensor]=None, lids: Optional[torch.Tensor]=None) -> Dict[(str, torch.Tensor)]:
'Calculate features and return them as a dict.\n\n Args:\n text (Tensor): Text index tensor (B, T_text).\n text_lengths (Tensor): Text length tensor (B,).\n speech (Tensor): Speech waveform tensor (B, T_wav).\n speech_lengths (Tensor): Speech length tensor (B, 1).\n spembs (Optional[Tensor]): Speaker embedding tensor (B, D).\n sids (Optional[Tensor]): Speaker index tensor (B, 1).\n lids (Optional[Tensor]): Language ID tensor (B, 1).\n\n Returns:\n Dict[str, Tensor]: Dict of features.\n\n '
feats = None
if (self.feats_extract is not None):
(feats, feats_lengths) = self.feats_extract(speech, speech_lengths)
feats_dict = {}
if (feats is not None):
feats_dict.update(feats=feats, feats_lengths=feats_lengths)
return feats_dict
| -8,469,345,931,603,927,000
|
Calculate features and return them as a dict.
Args:
text (Tensor): Text index tensor (B, T_text).
text_lengths (Tensor): Text length tensor (B,).
speech (Tensor): Speech waveform tensor (B, T_wav).
speech_lengths (Tensor): Speech length tensor (B, 1).
spembs (Optional[Tensor]): Speaker embedding tensor (B, D).
sids (Optional[Tensor]): Speaker index tensor (B, 1).
lids (Optional[Tensor]): Language ID tensor (B, 1).
Returns:
Dict[str, Tensor]: Dict of features.
|
espnet2/gan_tts/espnet_model.py
|
collect_feats
|
actboy/espnet
|
python
|
def collect_feats(self, text: torch.Tensor, text_lengths: torch.Tensor, speech: torch.Tensor, speech_lengths: torch.Tensor, spembs: Optional[torch.Tensor]=None, sids: Optional[torch.Tensor]=None, lids: Optional[torch.Tensor]=None) -> Dict[(str, torch.Tensor)]:
'Calculate features and return them as a dict.\n\n Args:\n text (Tensor): Text index tensor (B, T_text).\n text_lengths (Tensor): Text length tensor (B,).\n speech (Tensor): Speech waveform tensor (B, T_wav).\n speech_lengths (Tensor): Speech length tensor (B, 1).\n spembs (Optional[Tensor]): Speaker embedding tensor (B, D).\n sids (Optional[Tensor]): Speaker index tensor (B, 1).\n lids (Optional[Tensor]): Language ID tensor (B, 1).\n\n Returns:\n Dict[str, Tensor]: Dict of features.\n\n '
feats = None
if (self.feats_extract is not None):
(feats, feats_lengths) = self.feats_extract(speech, speech_lengths)
feats_dict = {}
if (feats is not None):
feats_dict.update(feats=feats, feats_lengths=feats_lengths)
return feats_dict
|
@staticmethod
def factory(sql_connection_type: SqlDialect, **kwargs) -> 'SqlConnectionOptions':
'\n Function signatures for factory method\n\n Postgres: (dialect: SqlDialects, host: str, port: int, username: str, password: str,\n database_name: str, timeout: int = None)\n '
return SqlConnectionFactories.get_factory(sql_connection_type)(**kwargs)
| -2,160,951,259,533,789,000
|
Function signatures for factory method
Postgres: (dialect: SqlDialects, host: str, port: int, username: str, password: str,
database_name: str, timeout: int = None)
|
flask_app/utilities/DataInterfaces/SqlInterface.py
|
factory
|
cliftbar/flask_app_template
|
python
|
@staticmethod
def factory(sql_connection_type: SqlDialect, **kwargs) -> 'SqlConnectionOptions':
'\n Function signatures for factory method\n\n Postgres: (dialect: SqlDialects, host: str, port: int, username: str, password: str,\n database_name: str, timeout: int = None)\n '
return SqlConnectionFactories.get_factory(sql_connection_type)(**kwargs)
|
def get_latest_version() -> str:
'\n :return: The latest available version in the format "vX.Y.Z"\n '
subdomain = ('staging.' if config.is_staging.value else '')
credentials = config.staging_credentials()
url = BRAINFRAME_LATEST_TAG_URL.format(subdomain=subdomain)
response = requests.get(url, auth=credentials)
return response.text
| -3,277,660,655,089,626,000
|
:return: The latest available version in the format "vX.Y.Z"
|
brainframe/cli/docker_compose.py
|
get_latest_version
|
aotuai/brainframe-cli
|
python
|
def get_latest_version() -> str:
'\n \n '
subdomain = ('staging.' if config.is_staging.value else )
credentials = config.staging_credentials()
url = BRAINFRAME_LATEST_TAG_URL.format(subdomain=subdomain)
response = requests.get(url, auth=credentials)
return response.text
|
def _assert_has_docker_permissions() -> None:
'Fails if the user does not have permissions to interact with Docker'
if (not (os_utils.is_root() or os_utils.currently_in_group('docker'))):
error_message = ((i18n.t('general.docker-bad-permissions') + '\n') + _group_recommendation_message('docker'))
print_utils.fail(error_message)
| 3,725,551,011,273,241,600
|
Fails if the user does not have permissions to interact with Docker
|
brainframe/cli/docker_compose.py
|
_assert_has_docker_permissions
|
aotuai/brainframe-cli
|
python
|
def _assert_has_docker_permissions() -> None:
if (not (os_utils.is_root() or os_utils.currently_in_group('docker'))):
error_message = ((i18n.t('general.docker-bad-permissions') + '\n') + _group_recommendation_message('docker'))
print_utils.fail(error_message)
|
def _assert_has_write_permissions(path: Path) -> None:
'Fails if the user does not have write access to the given path.'
if os.access(path, os.W_OK):
return
error_message = i18n.t('general.file-bad-write-permissions', path=path)
error_message += '\n'
if (path.stat().st_gid == os_utils.BRAINFRAME_GROUP_ID):
error_message += (' ' + _group_recommendation_message('brainframe'))
else:
error_message += (' ' + i18n.t('general.unexpected-group-for-file', path=path, group='brainframe'))
print_utils.fail(error_message)
| -1,048,546,519,596,421,600
|
Fails if the user does not have write access to the given path.
|
brainframe/cli/docker_compose.py
|
_assert_has_write_permissions
|
aotuai/brainframe-cli
|
python
|
def _assert_has_write_permissions(path: Path) -> None:
if os.access(path, os.W_OK):
return
error_message = i18n.t('general.file-bad-write-permissions', path=path)
error_message += '\n'
if (path.stat().st_gid == os_utils.BRAINFRAME_GROUP_ID):
error_message += (' ' + _group_recommendation_message('brainframe'))
else:
error_message += (' ' + i18n.t('general.unexpected-group-for-file', path=path, group='brainframe'))
print_utils.fail(error_message)
|
def configure_logger(path: pathlib.Path, verbose: bool=False) -> logging.Logger:
'Configure logger\n\n Args:\n path (pathlib.Path): Path where the persistent logger should write to.\n verbose (bool, optional): Use verbose logging. Defaults to False.\n\n Returns:\n logging.Logger: Created logger\n '
path.parent.mkdir(parents=True, exist_ok=True)
logger = logging.getLogger()
logger.setLevel(logging.INFO)
log_file_formatter = logging.Formatter('%(asctime)s %(threadName)s %(levelname)s %(name)s %(message)s')
if verbose:
log_console_formatter = logging.Formatter('[c8ylp] %(levelname)-5s %(message)s')
console_loglevel = logging.INFO
if (len(logger.handlers) == 0):
console_handler = logging.StreamHandler()
console_handler.setFormatter(log_console_formatter)
console_handler.setLevel(console_loglevel)
logger.addHandler(console_handler)
else:
handler = logger.handlers[0]
handler.setLevel(console_loglevel)
handler.setFormatter(log_console_formatter)
else:
logger.handlers = []
rotate_handler = RotatingFileHandler(filename=str(path), maxBytes=10000000, backupCount=5)
rotate_handler.setFormatter(log_file_formatter)
rotate_handler.setLevel(logging.INFO)
logger.addHandler(rotate_handler)
return logger
| 664,404,265,283,654,300
|
Configure logger
Args:
path (pathlib.Path): Path where the persistent logger should write to.
verbose (bool, optional): Use verbose logging. Defaults to False.
Returns:
logging.Logger: Created logger
|
c8ylp/cli/core.py
|
configure_logger
|
SoftwareAG/cumulocity-remote-access-local-proxy
|
python
|
def configure_logger(path: pathlib.Path, verbose: bool=False) -> logging.Logger:
'Configure logger\n\n Args:\n path (pathlib.Path): Path where the persistent logger should write to.\n verbose (bool, optional): Use verbose logging. Defaults to False.\n\n Returns:\n logging.Logger: Created logger\n '
path.parent.mkdir(parents=True, exist_ok=True)
logger = logging.getLogger()
logger.setLevel(logging.INFO)
log_file_formatter = logging.Formatter('%(asctime)s %(threadName)s %(levelname)s %(name)s %(message)s')
if verbose:
log_console_formatter = logging.Formatter('[c8ylp] %(levelname)-5s %(message)s')
console_loglevel = logging.INFO
if (len(logger.handlers) == 0):
console_handler = logging.StreamHandler()
console_handler.setFormatter(log_console_formatter)
console_handler.setLevel(console_loglevel)
logger.addHandler(console_handler)
else:
handler = logger.handlers[0]
handler.setLevel(console_loglevel)
handler.setFormatter(log_console_formatter)
else:
logger.handlers = []
rotate_handler = RotatingFileHandler(filename=str(path), maxBytes=10000000, backupCount=5)
rotate_handler.setFormatter(log_file_formatter)
rotate_handler.setLevel(logging.INFO)
logger.addHandler(rotate_handler)
return logger
|
def signal_handler(_signal, _frame):
'Signal handler'
sys.exit(ExitCodes.TERMINATE)
| 1,730,254,604,786,225,000
|
Signal handler
|
c8ylp/cli/core.py
|
signal_handler
|
SoftwareAG/cumulocity-remote-access-local-proxy
|
python
|
def signal_handler(_signal, _frame):
sys.exit(ExitCodes.TERMINATE)
|
def register_signals():
'Register signal handlers'
signal.signal(signal.SIGINT, signal_handler)
| 7,165,289,326,244,733,000
|
Register signal handlers
|
c8ylp/cli/core.py
|
register_signals
|
SoftwareAG/cumulocity-remote-access-local-proxy
|
python
|
def register_signals():
signal.signal(signal.SIGINT, signal_handler)
|
def create_client(ctx: click.Context, opts: ProxyContext) -> CumulocityClient:
'Create Cumulocity client and prompt for missing credentials\n if necessary.\n\n Args:\n ctx (click.Context): Click context\n opts (ProxyContext): Proxy options\n\n Returns:\n CumulocityClient: Configured Cumulocity client\n '
if ((not opts.disable_prompts) and (not opts.host)):
opts.host = click.prompt(text='Enter the Cumulocity Host/URL')
client = CumulocityClient(hostname=opts.host, tenant=opts.tenant, user=opts.user, password=opts.password, tfacode=opts.tfa_code, token=opts.token, ignore_ssl_validate=opts.ignore_ssl_validate)
if (not client.url):
opts.show_error('No Cumulocity host was provided. The host can be set viaenvironment variables, arguments or the env-file')
ctx.exit(ExitCodes.NO_SESSION)
logging.info('Checking tenant id')
client.validate_tenant_id()
retries = 3
success = False
while retries:
try:
if client.token:
client.validate_credentials()
else:
client.login()
if (opts.env_file and opts.store_token):
store_credentials(opts, client)
success = True
break
except CumulocityMissingTFAToken as ex:
client.tfacode = click.prompt(text='Enter your Cumulocity TFA-Token', hide_input=False)
except Exception as ex:
logging.info('unknown exception: %s', ex)
if (not opts.disable_prompts):
if (not client.user):
client.user = click.prompt(text='Enter your Cumulocity Username')
if (not client.password):
client.password = click.prompt(text='Enter your Cumulocity Password [input hidden]', hide_input=True)
retries -= 1
if (not success):
logging.info('Could not create client')
ctx.exit(ExitCodes.NO_SESSION)
return client
| 180,156,177,567,948,860
|
Create Cumulocity client and prompt for missing credentials
if necessary.
Args:
ctx (click.Context): Click context
opts (ProxyContext): Proxy options
Returns:
CumulocityClient: Configured Cumulocity client
|
c8ylp/cli/core.py
|
create_client
|
SoftwareAG/cumulocity-remote-access-local-proxy
|
python
|
def create_client(ctx: click.Context, opts: ProxyContext) -> CumulocityClient:
'Create Cumulocity client and prompt for missing credentials\n if necessary.\n\n Args:\n ctx (click.Context): Click context\n opts (ProxyContext): Proxy options\n\n Returns:\n CumulocityClient: Configured Cumulocity client\n '
if ((not opts.disable_prompts) and (not opts.host)):
opts.host = click.prompt(text='Enter the Cumulocity Host/URL')
client = CumulocityClient(hostname=opts.host, tenant=opts.tenant, user=opts.user, password=opts.password, tfacode=opts.tfa_code, token=opts.token, ignore_ssl_validate=opts.ignore_ssl_validate)
if (not client.url):
opts.show_error('No Cumulocity host was provided. The host can be set viaenvironment variables, arguments or the env-file')
ctx.exit(ExitCodes.NO_SESSION)
logging.info('Checking tenant id')
client.validate_tenant_id()
retries = 3
success = False
while retries:
try:
if client.token:
client.validate_credentials()
else:
client.login()
if (opts.env_file and opts.store_token):
store_credentials(opts, client)
success = True
break
except CumulocityMissingTFAToken as ex:
client.tfacode = click.prompt(text='Enter your Cumulocity TFA-Token', hide_input=False)
except Exception as ex:
logging.info('unknown exception: %s', ex)
if (not opts.disable_prompts):
if (not client.user):
client.user = click.prompt(text='Enter your Cumulocity Username')
if (not client.password):
client.password = click.prompt(text='Enter your Cumulocity Password [input hidden]', hide_input=True)
retries -= 1
if (not success):
logging.info('Could not create client')
ctx.exit(ExitCodes.NO_SESSION)
return client
|
def store_credentials(opts: ProxyContext, client: CumulocityClient):
'Store credentials to the environment file. It creates\n the file if it does not already exist.\n\n The file will only be written to if it has changed.\n\n Args:\n opts (ProxyContext): Proxy options\n client (CumulocityClient): Cumulocity client containing valid\n credentials\n '
changed = save_env(opts.env_file, {'C8Y_HOST': client.url, 'C8Y_USER': client.user, 'C8Y_TENANT': client.tenant, 'C8Y_TOKEN': client.token})
if changed:
opts.show_message(f'Env file was updated: {opts.env_file}')
else:
opts.show_info(f'Env file is already up to date: {opts.env_file}')
| -3,190,738,371,489,343,000
|
Store credentials to the environment file. It creates
the file if it does not already exist.
The file will only be written to if it has changed.
Args:
opts (ProxyContext): Proxy options
client (CumulocityClient): Cumulocity client containing valid
credentials
|
c8ylp/cli/core.py
|
store_credentials
|
SoftwareAG/cumulocity-remote-access-local-proxy
|
python
|
def store_credentials(opts: ProxyContext, client: CumulocityClient):
'Store credentials to the environment file. It creates\n the file if it does not already exist.\n\n The file will only be written to if it has changed.\n\n Args:\n opts (ProxyContext): Proxy options\n client (CumulocityClient): Cumulocity client containing valid\n credentials\n '
changed = save_env(opts.env_file, {'C8Y_HOST': client.url, 'C8Y_USER': client.user, 'C8Y_TENANT': client.tenant, 'C8Y_TOKEN': client.token})
if changed:
opts.show_message(f'Env file was updated: {opts.env_file}')
else:
opts.show_info(f'Env file is already up to date: {opts.env_file}')
|
def get_config_id(ctx: click.Context, mor: Dict[(str, Any)], config: str) -> str:
'Get the remote access configuration id matching a specific type\n from a device managed object\n\n Args:\n mor (Dict[str, Any]): Device managed object\n config (str): Expected configuration type\n\n Returns:\n str: Remote access configuration id\n '
device_name = mor.get('name', '<<empty_name>>')
if (REMOTE_ACCESS_FRAGMENT not in mor):
logging.error('No Remote Access Configuration has been found for device "%s"', device_name)
ctx.exit(ExitCodes.DEVICE_MISSING_REMOTE_ACCESS_FRAGMENT)
valid_configs = [item for item in mor.get(REMOTE_ACCESS_FRAGMENT, []) if (item.get('protocol') == PASSTHROUGH)]
if (not valid_configs):
logging.error('No config with protocol set to "%s" has been found for device "%s"', PASSTHROUGH, device_name)
ctx.exit(ExitCodes.DEVICE_NO_PASSTHROUGH_CONFIG)
def extract_config_id(matching_config):
logging.info('Using Configuration with Name "%s" and Remote Port %s', matching_config.get('name'), matching_config.get('port'))
return matching_config.get('id')
if (not config):
return extract_config_id(valid_configs[0])
matches = [item for item in valid_configs if (item.get('name', '').casefold() == config.casefold())]
if (not matches):
logging.error('Provided config name "%s" for "%s" was not found or none with protocal set to "%s"', config, device_name, PASSTHROUGH)
ctx.exit(ExitCodes.DEVICE_NO_MATCHING_PASSTHROUGH_CONFIG)
return extract_config_id(matches[0])
| 6,785,673,878,745,491,000
|
Get the remote access configuration id matching a specific type
from a device managed object
Args:
mor (Dict[str, Any]): Device managed object
config (str): Expected configuration type
Returns:
str: Remote access configuration id
|
c8ylp/cli/core.py
|
get_config_id
|
SoftwareAG/cumulocity-remote-access-local-proxy
|
python
|
def get_config_id(ctx: click.Context, mor: Dict[(str, Any)], config: str) -> str:
'Get the remote access configuration id matching a specific type\n from a device managed object\n\n Args:\n mor (Dict[str, Any]): Device managed object\n config (str): Expected configuration type\n\n Returns:\n str: Remote access configuration id\n '
device_name = mor.get('name', '<<empty_name>>')
if (REMOTE_ACCESS_FRAGMENT not in mor):
logging.error('No Remote Access Configuration has been found for device "%s"', device_name)
ctx.exit(ExitCodes.DEVICE_MISSING_REMOTE_ACCESS_FRAGMENT)
valid_configs = [item for item in mor.get(REMOTE_ACCESS_FRAGMENT, []) if (item.get('protocol') == PASSTHROUGH)]
if (not valid_configs):
logging.error('No config with protocol set to "%s" has been found for device "%s"', PASSTHROUGH, device_name)
ctx.exit(ExitCodes.DEVICE_NO_PASSTHROUGH_CONFIG)
def extract_config_id(matching_config):
logging.info('Using Configuration with Name "%s" and Remote Port %s', matching_config.get('name'), matching_config.get('port'))
return matching_config.get('id')
if (not config):
return extract_config_id(valid_configs[0])
matches = [item for item in valid_configs if (item.get('name', ).casefold() == config.casefold())]
if (not matches):
logging.error('Provided config name "%s" for "%s" was not found or none with protocal set to "%s"', config, device_name, PASSTHROUGH)
ctx.exit(ExitCodes.DEVICE_NO_MATCHING_PASSTHROUGH_CONFIG)
return extract_config_id(matches[0])
|
def run_proxy_in_background(ctx: click.Context, opts: ProxyContext, connection_data: RemoteAccessConnectionData, ready_signal: threading.Event=None):
'Run the proxy in a background thread\n\n Args:\n ctx (click.Context): Click context\n opts (ProxyContext): Proxy options\n connection_data (RemoteAccessConnectionData): Remote access connection data\n '
stop_signal = threading.Event()
_local_ready_signal = threading.Event()
register_signals()
background = threading.Thread(target=start_proxy, args=(ctx, opts), kwargs=dict(connection_data=connection_data, stop_signal=stop_signal, ready_signal=_local_ready_signal), daemon=True)
background.start()
if (not _local_ready_signal.wait(opts.wait_port_timeout)):
opts.exit_server_not_ready()
opts.set_env()
timer = CommandTimer('Duration', on_exit=click.echo).start()
@ctx.call_on_close
def _shutdown_server_thread():
stop_signal.set()
background.join()
timer.stop_with_message()
if ready_signal:
ready_signal.set()
| -36,272,710,872,368,430
|
Run the proxy in a background thread
Args:
ctx (click.Context): Click context
opts (ProxyContext): Proxy options
connection_data (RemoteAccessConnectionData): Remote access connection data
|
c8ylp/cli/core.py
|
run_proxy_in_background
|
SoftwareAG/cumulocity-remote-access-local-proxy
|
python
|
def run_proxy_in_background(ctx: click.Context, opts: ProxyContext, connection_data: RemoteAccessConnectionData, ready_signal: threading.Event=None):
'Run the proxy in a background thread\n\n Args:\n ctx (click.Context): Click context\n opts (ProxyContext): Proxy options\n connection_data (RemoteAccessConnectionData): Remote access connection data\n '
stop_signal = threading.Event()
_local_ready_signal = threading.Event()
register_signals()
background = threading.Thread(target=start_proxy, args=(ctx, opts), kwargs=dict(connection_data=connection_data, stop_signal=stop_signal, ready_signal=_local_ready_signal), daemon=True)
background.start()
if (not _local_ready_signal.wait(opts.wait_port_timeout)):
opts.exit_server_not_ready()
opts.set_env()
timer = CommandTimer('Duration', on_exit=click.echo).start()
@ctx.call_on_close
def _shutdown_server_thread():
stop_signal.set()
background.join()
timer.stop_with_message()
if ready_signal:
ready_signal.set()
|
def pre_start_checks(ctx: click.Context, opts: ProxyContext) -> Optional[RemoteAccessConnectionData]:
'Run prestart checks before starting the local proxy\n\n Args:\n ctx (click.Context): Click context\n opts (ProxyContext): Proxy options\n\n Returns:\n Optional[RemoteAccessConnectionData]: Remote access connection data\n '
try:
client = create_client(ctx, opts)
mor = client.get_managed_object(opts.device, opts.external_type)
config_id = get_config_id(ctx, mor, opts.config)
device_id = mor.get('id')
is_authorized = client.validate_remote_access_role()
if (not is_authorized):
opts.show_error(f'The user is not authorized to use Cloud Remote Access. Contact your Cumulocity Admin. user={opts.user}')
ctx.exit(ExitCodes.MISSING_ROLE_REMOTE_ACCESS_ADMIN)
except Exception as ex:
if isinstance(ex, click.exceptions.Exit):
opts.show_error(f'Could not retrieve device information. reason={ex}')
raise
error_context = ''
extra_details = []
if (opts.host and (opts.host not in str(ex))):
extra_details.append(f"host={(opts.host or '')}")
if (opts.user and (opts.user not in str(ex))):
extra_details.append(f"user={(opts.user or '')}")
if extra_details:
error_context = ('. settings: ' + ', '.join(extra_details))
opts.show_error(f'Unexpected error when retrieving device information from Cumulocity. error_details={ex}{error_context}')
ctx.exit(ExitCodes.NOT_AUTHORIZED)
return RemoteAccessConnectionData(client=client, managed_object_id=device_id, remote_config_id=config_id)
| 3,013,459,128,331,044,000
|
Run prestart checks before starting the local proxy
Args:
ctx (click.Context): Click context
opts (ProxyContext): Proxy options
Returns:
Optional[RemoteAccessConnectionData]: Remote access connection data
|
c8ylp/cli/core.py
|
pre_start_checks
|
SoftwareAG/cumulocity-remote-access-local-proxy
|
python
|
def pre_start_checks(ctx: click.Context, opts: ProxyContext) -> Optional[RemoteAccessConnectionData]:
'Run prestart checks before starting the local proxy\n\n Args:\n ctx (click.Context): Click context\n opts (ProxyContext): Proxy options\n\n Returns:\n Optional[RemoteAccessConnectionData]: Remote access connection data\n '
try:
client = create_client(ctx, opts)
mor = client.get_managed_object(opts.device, opts.external_type)
config_id = get_config_id(ctx, mor, opts.config)
device_id = mor.get('id')
is_authorized = client.validate_remote_access_role()
if (not is_authorized):
opts.show_error(f'The user is not authorized to use Cloud Remote Access. Contact your Cumulocity Admin. user={opts.user}')
ctx.exit(ExitCodes.MISSING_ROLE_REMOTE_ACCESS_ADMIN)
except Exception as ex:
if isinstance(ex, click.exceptions.Exit):
opts.show_error(f'Could not retrieve device information. reason={ex}')
raise
error_context =
extra_details = []
if (opts.host and (opts.host not in str(ex))):
extra_details.append(f"host={(opts.host or )}")
if (opts.user and (opts.user not in str(ex))):
extra_details.append(f"user={(opts.user or )}")
if extra_details:
error_context = ('. settings: ' + ', '.join(extra_details))
opts.show_error(f'Unexpected error when retrieving device information from Cumulocity. error_details={ex}{error_context}')
ctx.exit(ExitCodes.NOT_AUTHORIZED)
return RemoteAccessConnectionData(client=client, managed_object_id=device_id, remote_config_id=config_id)
|
def start_proxy(ctx: click.Context, opts: ProxyContext, connection_data: RemoteAccessConnectionData, stop_signal: threading.Event=None, ready_signal: threading.Event=None) -> NoReturn:
'Start the local proxy\n\n Args:\n ctx (click.Context): Click context\n opts (ProxyContext): Proxy options\n '
is_main_thread = (threading.current_thread() is threading.main_thread())
if is_main_thread:
register_signals()
client_opts = {'host': opts.host, 'config_id': connection_data.remote_config_id, 'device_id': connection_data.managed_object_id, 'session': connection_data.client.session, 'token': opts.token, 'ignore_ssl_validate': opts.ignore_ssl_validate, 'ping_interval': opts.ping_interval, 'max_retries': 2}
tcp_server = None
background = None
try:
tcp_server = TCPProxyServer(opts.port, WebsocketClient(**client_opts), opts.tcp_size, opts.tcp_timeout)
exit_code = ExitCodes.OK
click.secho(BANNER1)
logging.info('Starting tcp server')
background = threading.Thread(target=tcp_server.serve_forever, daemon=True)
background.start()
if (not tcp_server.wait_for_running(opts.wait_port_timeout)):
opts.exit_server_not_ready()
if tcp_server.server.socket:
opts.used_port = tcp_server.server.socket.getsockname()[1]
if is_main_thread:
opts.show_info(f'''
c8ylp is listening for device (ext_id) {opts.device} ({opts.host}) on localhost:{opts.used_port}''')
ssh_username = (opts.ssh_user or '<device_username>')
opts.show_message(f'''
For example, if you are running a ssh proxy, you connect to {opts.device} by executing the following in a new tab/console:
ssh -p {opts.used_port} {ssh_username}@localhost''')
opts.show_info('\nPress ctrl-c to shutdown the server')
if ready_signal:
ready_signal.set()
while background.is_alive():
if (stop_signal and stop_signal.is_set()):
break
time.sleep(1)
logging.debug('Waiting in background: alive=%s', background.is_alive())
except Exception as ex:
if isinstance(ex, click.exceptions.Exit):
exit_code = getattr(ex, 'exit_code')
raise
if str(ex):
opts.show_error(f'The local proxy TCP Server experienced an unexpected error. port={opts.port}, error={ex}')
exit_code = ExitCodes.UNKNOWN
finally:
if tcp_server:
tcp_server.shutdown()
if background:
background.join()
if is_main_thread:
if (int(exit_code) == 0):
opts.show_message(f'Exiting: {str(exit_code)} ({int(exit_code)})')
else:
opts.show_error(f'Exiting: {str(exit_code)} ({int(exit_code)})')
ctx.exit(exit_code)
else:
opts.show_info('Exiting')
| 6,606,672,606,113,287,000
|
Start the local proxy
Args:
ctx (click.Context): Click context
opts (ProxyContext): Proxy options
|
c8ylp/cli/core.py
|
start_proxy
|
SoftwareAG/cumulocity-remote-access-local-proxy
|
python
|
def start_proxy(ctx: click.Context, opts: ProxyContext, connection_data: RemoteAccessConnectionData, stop_signal: threading.Event=None, ready_signal: threading.Event=None) -> NoReturn:
'Start the local proxy\n\n Args:\n ctx (click.Context): Click context\n opts (ProxyContext): Proxy options\n '
is_main_thread = (threading.current_thread() is threading.main_thread())
if is_main_thread:
register_signals()
client_opts = {'host': opts.host, 'config_id': connection_data.remote_config_id, 'device_id': connection_data.managed_object_id, 'session': connection_data.client.session, 'token': opts.token, 'ignore_ssl_validate': opts.ignore_ssl_validate, 'ping_interval': opts.ping_interval, 'max_retries': 2}
tcp_server = None
background = None
try:
tcp_server = TCPProxyServer(opts.port, WebsocketClient(**client_opts), opts.tcp_size, opts.tcp_timeout)
exit_code = ExitCodes.OK
click.secho(BANNER1)
logging.info('Starting tcp server')
background = threading.Thread(target=tcp_server.serve_forever, daemon=True)
background.start()
if (not tcp_server.wait_for_running(opts.wait_port_timeout)):
opts.exit_server_not_ready()
if tcp_server.server.socket:
opts.used_port = tcp_server.server.socket.getsockname()[1]
if is_main_thread:
opts.show_info(f'
c8ylp is listening for device (ext_id) {opts.device} ({opts.host}) on localhost:{opts.used_port}')
ssh_username = (opts.ssh_user or '<device_username>')
opts.show_message(f'
For example, if you are running a ssh proxy, you connect to {opts.device} by executing the following in a new tab/console:
ssh -p {opts.used_port} {ssh_username}@localhost')
opts.show_info('\nPress ctrl-c to shutdown the server')
if ready_signal:
ready_signal.set()
while background.is_alive():
if (stop_signal and stop_signal.is_set()):
break
time.sleep(1)
logging.debug('Waiting in background: alive=%s', background.is_alive())
except Exception as ex:
if isinstance(ex, click.exceptions.Exit):
exit_code = getattr(ex, 'exit_code')
raise
if str(ex):
opts.show_error(f'The local proxy TCP Server experienced an unexpected error. port={opts.port}, error={ex}')
exit_code = ExitCodes.UNKNOWN
finally:
if tcp_server:
tcp_server.shutdown()
if background:
background.join()
if is_main_thread:
if (int(exit_code) == 0):
opts.show_message(f'Exiting: {str(exit_code)} ({int(exit_code)})')
else:
opts.show_error(f'Exiting: {str(exit_code)} ({int(exit_code)})')
ctx.exit(exit_code)
else:
opts.show_info('Exiting')
|
@property
def used_port(self) -> int:
'Get the port used by the local proxy\n\n Returns:\n int: Port number\n '
return self._root_context.get('used_port', self.port)
| 8,691,517,613,530,922,000
|
Get the port used by the local proxy
Returns:
int: Port number
|
c8ylp/cli/core.py
|
used_port
|
SoftwareAG/cumulocity-remote-access-local-proxy
|
python
|
@property
def used_port(self) -> int:
'Get the port used by the local proxy\n\n Returns:\n int: Port number\n '
return self._root_context.get('used_port', self.port)
|
@used_port.setter
def used_port(self, value: int):
'Store the port used by the local proxy for later reference\n\n Args:\n value (int): Port number\n '
self._root_context['used_port'] = value
| -7,539,411,045,327,996,000
|
Store the port used by the local proxy for later reference
Args:
value (int): Port number
|
c8ylp/cli/core.py
|
used_port
|
SoftwareAG/cumulocity-remote-access-local-proxy
|
python
|
@used_port.setter
def used_port(self, value: int):
'Store the port used by the local proxy for later reference\n\n Args:\n value (int): Port number\n '
self._root_context['used_port'] = value
|
def exit_server_not_ready(self) -> NoReturn:
'Exit with a server not ready error\n\n Returns:\n NoReturn: The function does not return\n '
self.show_error(f'Timed out waiting for local port to open: port={self.used_port}, timeout={self.wait_port_timeout}s')
self._ctx.exit(ExitCodes.TIMEOUT_WAIT_FOR_PORT)
| -3,488,656,533,846,449,700
|
Exit with a server not ready error
Returns:
NoReturn: The function does not return
|
c8ylp/cli/core.py
|
exit_server_not_ready
|
SoftwareAG/cumulocity-remote-access-local-proxy
|
python
|
def exit_server_not_ready(self) -> NoReturn:
'Exit with a server not ready error\n\n Returns:\n NoReturn: The function does not return\n '
self.show_error(f'Timed out waiting for local port to open: port={self.used_port}, timeout={self.wait_port_timeout}s')
self._ctx.exit(ExitCodes.TIMEOUT_WAIT_FOR_PORT)
|
def fromdict(self, src_dict: Dict[(str, Any)]) -> 'ProxyContext':
'Load proxy settings from a dictionary\n\n Args:\n src_dict (Dict[str, Any]): [description]\n\n Returns:\n ProxyContext: Proxy options after the values have been set\n via the dictionary\n '
logging.info('Loading from dictionary')
assert isinstance(src_dict, dict)
for (key, value) in src_dict.items():
logging.info('reading key: %s=%s', key, value)
if hasattr(self, key):
setattr(self, key, value)
return self
| 6,400,380,737,886,094,000
|
Load proxy settings from a dictionary
Args:
src_dict (Dict[str, Any]): [description]
Returns:
ProxyContext: Proxy options after the values have been set
via the dictionary
|
c8ylp/cli/core.py
|
fromdict
|
SoftwareAG/cumulocity-remote-access-local-proxy
|
python
|
def fromdict(self, src_dict: Dict[(str, Any)]) -> 'ProxyContext':
'Load proxy settings from a dictionary\n\n Args:\n src_dict (Dict[str, Any]): [description]\n\n Returns:\n ProxyContext: Proxy options after the values have been set\n via the dictionary\n '
logging.info('Loading from dictionary')
assert isinstance(src_dict, dict)
for (key, value) in src_dict.items():
logging.info('reading key: %s=%s', key, value)
if hasattr(self, key):
setattr(self, key, value)
return self
|
def start_background(self, ctx: click.Context=None) -> 'ProxyContext':
'Start the local proxy in the background\n\n Returns:\n ProxyContext: Reference to the proxy context so it can be chained\n with other commands or used after the initialization of the class.\n '
cur_ctx = (ctx or self._ctx)
connection_data = pre_start_checks(cur_ctx, self)
ready_signal = threading.Event()
run_proxy_in_background(cur_ctx, self, connection_data=connection_data, ready_signal=ready_signal)
if (not ready_signal.wait(self.wait_port_timeout)):
self.exit_server_not_ready()
return self
| 7,925,858,526,088,870,000
|
Start the local proxy in the background
Returns:
ProxyContext: Reference to the proxy context so it can be chained
with other commands or used after the initialization of the class.
|
c8ylp/cli/core.py
|
start_background
|
SoftwareAG/cumulocity-remote-access-local-proxy
|
python
|
def start_background(self, ctx: click.Context=None) -> 'ProxyContext':
'Start the local proxy in the background\n\n Returns:\n ProxyContext: Reference to the proxy context so it can be chained\n with other commands or used after the initialization of the class.\n '
cur_ctx = (ctx or self._ctx)
connection_data = pre_start_checks(cur_ctx, self)
ready_signal = threading.Event()
run_proxy_in_background(cur_ctx, self, connection_data=connection_data, ready_signal=ready_signal)
if (not ready_signal.wait(self.wait_port_timeout)):
self.exit_server_not_ready()
return self
|
def start(self, ctx: click.Context=None) -> None:
'Start the local proxy in the background\n\n Returns:\n ProxyContext: Reference to the proxy context so it can be chained\n with other commands or used after the initialization of the class.\n '
cur_ctx = (ctx or self._ctx)
connection_data = pre_start_checks(cur_ctx, self)
start_proxy(cur_ctx, self, connection_data=connection_data)
| -3,952,982,397,710,996,500
|
Start the local proxy in the background
Returns:
ProxyContext: Reference to the proxy context so it can be chained
with other commands or used after the initialization of the class.
|
c8ylp/cli/core.py
|
start
|
SoftwareAG/cumulocity-remote-access-local-proxy
|
python
|
def start(self, ctx: click.Context=None) -> None:
'Start the local proxy in the background\n\n Returns:\n ProxyContext: Reference to the proxy context so it can be chained\n with other commands or used after the initialization of the class.\n '
cur_ctx = (ctx or self._ctx)
connection_data = pre_start_checks(cur_ctx, self)
start_proxy(cur_ctx, self, connection_data=connection_data)
|
@classmethod
def show_message(cls, msg: str, *args, **kwargs):
'Show an message to the user and log it\n\n Args:\n msg (str): User message to print on the console\n '
click.secho(msg, fg='green')
logging.info(msg, *args, **kwargs)
| -635,830,249,380,264,400
|
Show an message to the user and log it
Args:
msg (str): User message to print on the console
|
c8ylp/cli/core.py
|
show_message
|
SoftwareAG/cumulocity-remote-access-local-proxy
|
python
|
@classmethod
def show_message(cls, msg: str, *args, **kwargs):
'Show an message to the user and log it\n\n Args:\n msg (str): User message to print on the console\n '
click.secho(msg, fg='green')
logging.info(msg, *args, **kwargs)
|
def show_error(self, msg: str, *args, **kwargs):
'Show an error to the user and log it\n\n Args:\n msg (str): User message to print on the console\n '
if (not self.verbose):
click.secho(msg, fg='red')
logging.warning(msg, *args, **kwargs)
| 6,178,511,922,028,288,000
|
Show an error to the user and log it
Args:
msg (str): User message to print on the console
|
c8ylp/cli/core.py
|
show_error
|
SoftwareAG/cumulocity-remote-access-local-proxy
|
python
|
def show_error(self, msg: str, *args, **kwargs):
'Show an error to the user and log it\n\n Args:\n msg (str): User message to print on the console\n '
if (not self.verbose):
click.secho(msg, fg='red')
logging.warning(msg, *args, **kwargs)
|
def show_info(self, msg: str, *args, **kwargs):
'Show an info message to the user and log it\n\n Args:\n msg (str): User message to print on the console\n '
if (not self.verbose):
click.secho(msg)
logging.warning(msg, *args, **kwargs)
| 3,718,197,683,893,955,600
|
Show an info message to the user and log it
Args:
msg (str): User message to print on the console
|
c8ylp/cli/core.py
|
show_info
|
SoftwareAG/cumulocity-remote-access-local-proxy
|
python
|
def show_info(self, msg: str, *args, **kwargs):
'Show an info message to the user and log it\n\n Args:\n msg (str): User message to print on the console\n '
if (not self.verbose):
click.secho(msg)
logging.warning(msg, *args, **kwargs)
|
def show_warning(self, msg: str, *args, **kwargs):
'Show a warning to the user and log it\n\n Args:\n msg (str): User message to print on the console\n '
if (not self.verbose):
click.secho(msg, fg='yellow')
logging.warning(msg, *args, **kwargs)
| -5,328,920,099,859,709,000
|
Show a warning to the user and log it
Args:
msg (str): User message to print on the console
|
c8ylp/cli/core.py
|
show_warning
|
SoftwareAG/cumulocity-remote-access-local-proxy
|
python
|
def show_warning(self, msg: str, *args, **kwargs):
'Show a warning to the user and log it\n\n Args:\n msg (str): User message to print on the console\n '
if (not self.verbose):
click.secho(msg, fg='yellow')
logging.warning(msg, *args, **kwargs)
|
def set_env(self):
'Set environment variables so information about the proxy can\n be access by plugins\n '
os.environ['C8Y_HOST'] = str(self.host)
os.environ['PORT'] = str(self.used_port)
os.environ['DEVICE'] = self.device
os.environ['WSLENV'] = 'PORT/u:DEVICE/u:C8Y_HOST/u'
| -3,005,475,876,850,048,500
|
Set environment variables so information about the proxy can
be access by plugins
|
c8ylp/cli/core.py
|
set_env
|
SoftwareAG/cumulocity-remote-access-local-proxy
|
python
|
def set_env(self):
'Set environment variables so information about the proxy can\n be access by plugins\n '
os.environ['C8Y_HOST'] = str(self.host)
os.environ['PORT'] = str(self.used_port)
os.environ['DEVICE'] = self.device
os.environ['WSLENV'] = 'PORT/u:DEVICE/u:C8Y_HOST/u'
|
@classmethod
def log_path(cls) -> pathlib.Path:
'Get the log path'
return (pathlib.Path(os.getenv('C8YLP_LOG_DIR', '~/.c8ylp/')).expanduser() / 'localproxy.log')
| -4,331,468,252,760,386,000
|
Get the log path
|
c8ylp/cli/core.py
|
log_path
|
SoftwareAG/cumulocity-remote-access-local-proxy
|
python
|
@classmethod
def log_path(cls) -> pathlib.Path:
return (pathlib.Path(os.getenv('C8YLP_LOG_DIR', '~/.c8ylp/')).expanduser() / 'localproxy.log')
|
def get_ffme_returns():
'\n Load the Fama-French Dataset for the returns of the Top and Bottom Deciles by MarketCap\n '
me_m = pd.read_csv('data/Portfolios_Formed_on_ME_monthly_EW.csv', header=0, index_col=0, na_values=(- 99.99))
rets = me_m[['Lo 10', 'Hi 10']]
rets.columns = ['SmallCap', 'LargeCap']
rets = (rets / 100)
rets.index = pd.to_datetime(rets.index, format='%Y%m').to_period('M')
return rets
| -8,356,439,846,472,406,000
|
Load the Fama-French Dataset for the returns of the Top and Bottom Deciles by MarketCap
|
kit.py
|
get_ffme_returns
|
jaimeaguilera/Investing-projects
|
python
|
def get_ffme_returns():
'\n \n '
me_m = pd.read_csv('data/Portfolios_Formed_on_ME_monthly_EW.csv', header=0, index_col=0, na_values=(- 99.99))
rets = me_m[['Lo 10', 'Hi 10']]
rets.columns = ['SmallCap', 'LargeCap']
rets = (rets / 100)
rets.index = pd.to_datetime(rets.index, format='%Y%m').to_period('M')
return rets
|
def get_fff_returns():
'\n Load the Fama-French Research Factor Monthly Dataset\n '
rets = (pd.read_csv('data/F-F_Research_Data_Factors_m.csv', header=0, index_col=0, na_values=(- 99.99)) / 100)
rets.index = pd.to_datetime(rets.index, format='%Y%m').to_period('M')
return rets
| -7,927,721,906,992,404,000
|
Load the Fama-French Research Factor Monthly Dataset
|
kit.py
|
get_fff_returns
|
jaimeaguilera/Investing-projects
|
python
|
def get_fff_returns():
'\n \n '
rets = (pd.read_csv('data/F-F_Research_Data_Factors_m.csv', header=0, index_col=0, na_values=(- 99.99)) / 100)
rets.index = pd.to_datetime(rets.index, format='%Y%m').to_period('M')
return rets
|
def get_hfi_returns():
'\n Load and format the EDHEC Hedge Fund Index Returns\n '
hfi = pd.read_csv('data/edhec-hedgefundindices.csv', header=0, index_col=0, parse_dates=True)
hfi = (hfi / 100)
hfi.index = hfi.index.to_period('M')
return hfi
| -2,043,821,786,576,152,000
|
Load and format the EDHEC Hedge Fund Index Returns
|
kit.py
|
get_hfi_returns
|
jaimeaguilera/Investing-projects
|
python
|
def get_hfi_returns():
'\n \n '
hfi = pd.read_csv('data/edhec-hedgefundindices.csv', header=0, index_col=0, parse_dates=True)
hfi = (hfi / 100)
hfi.index = hfi.index.to_period('M')
return hfi
|
def get_ind_file(filetype, weighting='vw', n_inds=30):
'\n Load and format the Ken French Industry Portfolios files\n Variant is a tuple of (weighting, size) where:\n weighting is one of "ew", "vw"\n number of inds is 30 or 49\n '
if (filetype is 'returns'):
name = f'{weighting}_rets'
divisor = 100
elif (filetype is 'nfirms'):
name = 'nfirms'
divisor = 1
elif (filetype is 'size'):
name = 'size'
divisor = 1
else:
raise ValueError(f'filetype must be one of: returns, nfirms, size')
ind = (pd.read_csv(f'data/ind{n_inds}_m_{name}.csv', header=0, index_col=0, na_values=(- 99.99)) / divisor)
ind.index = pd.to_datetime(ind.index, format='%Y%m').to_period('M')
ind.columns = ind.columns.str.strip()
return ind
| -1,716,315,270,824,754,000
|
Load and format the Ken French Industry Portfolios files
Variant is a tuple of (weighting, size) where:
weighting is one of "ew", "vw"
number of inds is 30 or 49
|
kit.py
|
get_ind_file
|
jaimeaguilera/Investing-projects
|
python
|
def get_ind_file(filetype, weighting='vw', n_inds=30):
'\n Load and format the Ken French Industry Portfolios files\n Variant is a tuple of (weighting, size) where:\n weighting is one of "ew", "vw"\n number of inds is 30 or 49\n '
if (filetype is 'returns'):
name = f'{weighting}_rets'
divisor = 100
elif (filetype is 'nfirms'):
name = 'nfirms'
divisor = 1
elif (filetype is 'size'):
name = 'size'
divisor = 1
else:
raise ValueError(f'filetype must be one of: returns, nfirms, size')
ind = (pd.read_csv(f'data/ind{n_inds}_m_{name}.csv', header=0, index_col=0, na_values=(- 99.99)) / divisor)
ind.index = pd.to_datetime(ind.index, format='%Y%m').to_period('M')
ind.columns = ind.columns.str.strip()
return ind
|
def get_ind_returns(weighting='vw', n_inds=30):
'\n Load and format the Ken French Industry Portfolios Monthly Returns\n '
return get_ind_file('returns', weighting=weighting, n_inds=n_inds)
| 8,765,230,633,926,116,000
|
Load and format the Ken French Industry Portfolios Monthly Returns
|
kit.py
|
get_ind_returns
|
jaimeaguilera/Investing-projects
|
python
|
def get_ind_returns(weighting='vw', n_inds=30):
'\n \n '
return get_ind_file('returns', weighting=weighting, n_inds=n_inds)
|
def get_ind_nfirms(n_inds=30):
'\n Load and format the Ken French 30 Industry Portfolios Average number of Firms\n '
return get_ind_file('nfirms', n_inds=n_inds)
| -3,638,385,353,629,806,600
|
Load and format the Ken French 30 Industry Portfolios Average number of Firms
|
kit.py
|
get_ind_nfirms
|
jaimeaguilera/Investing-projects
|
python
|
def get_ind_nfirms(n_inds=30):
'\n \n '
return get_ind_file('nfirms', n_inds=n_inds)
|
def get_ind_size(n_inds=30):
'\n Load and format the Ken French 30 Industry Portfolios Average size (market cap)\n '
return get_ind_file('size', n_inds=n_inds)
| -8,120,265,645,189,793,000
|
Load and format the Ken French 30 Industry Portfolios Average size (market cap)
|
kit.py
|
get_ind_size
|
jaimeaguilera/Investing-projects
|
python
|
def get_ind_size(n_inds=30):
'\n \n '
return get_ind_file('size', n_inds=n_inds)
|
def get_ind_market_caps(n_inds=30, weights=False):
'\n Load the industry portfolio data and derive the market caps\n '
ind_nfirms = get_ind_nfirms(n_inds=n_inds)
ind_size = get_ind_size(n_inds=n_inds)
ind_mktcap = (ind_nfirms * ind_size)
if weights:
total_mktcap = ind_mktcap.sum(axis=1)
ind_capweight = ind_mktcap.divide(total_mktcap, axis='rows')
return ind_capweight
return ind_mktcap
| -2,019,311,730,886,692,000
|
Load the industry portfolio data and derive the market caps
|
kit.py
|
get_ind_market_caps
|
jaimeaguilera/Investing-projects
|
python
|
def get_ind_market_caps(n_inds=30, weights=False):
'\n \n '
ind_nfirms = get_ind_nfirms(n_inds=n_inds)
ind_size = get_ind_size(n_inds=n_inds)
ind_mktcap = (ind_nfirms * ind_size)
if weights:
total_mktcap = ind_mktcap.sum(axis=1)
ind_capweight = ind_mktcap.divide(total_mktcap, axis='rows')
return ind_capweight
return ind_mktcap
|
def get_total_market_index_returns(n_inds=30):
'\n Load the 30 industry portfolio data and derive the returns of a capweighted total market index\n '
ind_capweight = get_ind_market_caps(n_inds=n_inds)
ind_return = get_ind_returns(weighting='vw', n_inds=n_inds)
total_market_return = (ind_capweight * ind_return).sum(axis='columns')
return total_market_return
| -2,314,792,494,135,799,300
|
Load the 30 industry portfolio data and derive the returns of a capweighted total market index
|
kit.py
|
get_total_market_index_returns
|
jaimeaguilera/Investing-projects
|
python
|
def get_total_market_index_returns(n_inds=30):
'\n \n '
ind_capweight = get_ind_market_caps(n_inds=n_inds)
ind_return = get_ind_returns(weighting='vw', n_inds=n_inds)
total_market_return = (ind_capweight * ind_return).sum(axis='columns')
return total_market_return
|
def skewness(r):
'\n Alternative to scipy.stats.skew()\n Computes the skewness of the supplied Series or DataFrame\n Returns a float or a Series\n '
r = r[((r != 0) & r.notnull())]
demeaned_r = (r - r.mean())
sigma_r = r.std(ddof=0)
exp = (demeaned_r ** 3).mean()
return (exp / (sigma_r ** 3))
| 7,755,191,297,281,593,000
|
Alternative to scipy.stats.skew()
Computes the skewness of the supplied Series or DataFrame
Returns a float or a Series
|
kit.py
|
skewness
|
jaimeaguilera/Investing-projects
|
python
|
def skewness(r):
'\n Alternative to scipy.stats.skew()\n Computes the skewness of the supplied Series or DataFrame\n Returns a float or a Series\n '
r = r[((r != 0) & r.notnull())]
demeaned_r = (r - r.mean())
sigma_r = r.std(ddof=0)
exp = (demeaned_r ** 3).mean()
return (exp / (sigma_r ** 3))
|
def kurtosis(r):
'\n Alternative to scipy.stats.kurtosis()\n Computes the kurtosis of the supplied Series or DataFrame\n Returns a float or a Series\n '
r = r[((r != 0) & r.notnull())]
demeaned_r = (r - r.mean())
sigma_r = r.std(ddof=0)
exp = (demeaned_r ** 4).mean()
return (exp / (sigma_r ** 4))
| -8,853,748,143,048,105,000
|
Alternative to scipy.stats.kurtosis()
Computes the kurtosis of the supplied Series or DataFrame
Returns a float or a Series
|
kit.py
|
kurtosis
|
jaimeaguilera/Investing-projects
|
python
|
def kurtosis(r):
'\n Alternative to scipy.stats.kurtosis()\n Computes the kurtosis of the supplied Series or DataFrame\n Returns a float or a Series\n '
r = r[((r != 0) & r.notnull())]
demeaned_r = (r - r.mean())
sigma_r = r.std(ddof=0)
exp = (demeaned_r ** 4).mean()
return (exp / (sigma_r ** 4))
|
def compound(r):
'\n returns the result of compounding the set of returns in r\n '
return np.expm1(np.log1p(r).sum())
| -5,716,126,220,503,370,000
|
returns the result of compounding the set of returns in r
|
kit.py
|
compound
|
jaimeaguilera/Investing-projects
|
python
|
def compound(r):
'\n \n '
return np.expm1(np.log1p(r).sum())
|
def annualize_rets(r):
'\n Annualizes a set of returns\n We should infer the periods per year\n but that is currently left as an exercise\n to the reader :-)\n '
r_valid = r[((r != 0) & r.notnull())]
date_beg = r_valid.agg((lambda x: x.first_valid_index()))
date_end = r_valid.agg((lambda x: x.last_valid_index()))
try:
years_fraction = ((date_end - date_beg).dt.days / 365.2425)
except:
years_fraction = ((date_end - date_beg).days / 365.2425)
compounded_growth = (1 + r_valid).prod()
return ((compounded_growth ** (1 / years_fraction)) - 1)
| 444,043,545,948,035,400
|
Annualizes a set of returns
We should infer the periods per year
but that is currently left as an exercise
to the reader :-)
|
kit.py
|
annualize_rets
|
jaimeaguilera/Investing-projects
|
python
|
def annualize_rets(r):
'\n Annualizes a set of returns\n We should infer the periods per year\n but that is currently left as an exercise\n to the reader :-)\n '
r_valid = r[((r != 0) & r.notnull())]
date_beg = r_valid.agg((lambda x: x.first_valid_index()))
date_end = r_valid.agg((lambda x: x.last_valid_index()))
try:
years_fraction = ((date_end - date_beg).dt.days / 365.2425)
except:
years_fraction = ((date_end - date_beg).days / 365.2425)
compounded_growth = (1 + r_valid).prod()
return ((compounded_growth ** (1 / years_fraction)) - 1)
|
def annualize_vol(r):
'\n Annualizes the vol of a set of returns\n We should infer the periods per year\n but that is currently left as an exercise\n to the reader :-)\n '
r_valid = r[((r != 0) & r.notnull())]
total_num_periods = r_valid.count()
date_beg = r_valid.agg((lambda x: x.first_valid_index()))
date_end = r_valid.agg((lambda x: x.last_valid_index()))
try:
years_fraction = ((date_end - date_beg).dt.days / 365.2425)
except:
years_fraction = ((date_end - date_beg).days / 365.2425)
periods_per_year = (total_num_periods / years_fraction)
return (r_valid.std() * (periods_per_year ** 0.5))
| 4,409,763,613,660,388,000
|
Annualizes the vol of a set of returns
We should infer the periods per year
but that is currently left as an exercise
to the reader :-)
|
kit.py
|
annualize_vol
|
jaimeaguilera/Investing-projects
|
python
|
def annualize_vol(r):
'\n Annualizes the vol of a set of returns\n We should infer the periods per year\n but that is currently left as an exercise\n to the reader :-)\n '
r_valid = r[((r != 0) & r.notnull())]
total_num_periods = r_valid.count()
date_beg = r_valid.agg((lambda x: x.first_valid_index()))
date_end = r_valid.agg((lambda x: x.last_valid_index()))
try:
years_fraction = ((date_end - date_beg).dt.days / 365.2425)
except:
years_fraction = ((date_end - date_beg).days / 365.2425)
periods_per_year = (total_num_periods / years_fraction)
return (r_valid.std() * (periods_per_year ** 0.5))
|
def sharpe_ratio(r, riskfree_rate):
'\n Computes the annualized sharpe ratio of a set of returns\n '
r_valid = r[((r != 0) & r.notnull())]
total_num_periods = r_valid.count()
date_beg = r_valid.agg((lambda x: x.first_valid_index()))
date_end = r_valid.agg((lambda x: x.last_valid_index()))
try:
years_fraction = ((date_end - date_beg).dt.days / 365.2425)
except:
years_fraction = ((date_end - date_beg).days / 365.2425)
periods_per_year = (total_num_periods / years_fraction)
rf_per_period = (((1 + riskfree_rate) ** (1 / periods_per_year)) - 1)
excess_ret = (r - rf_per_period)
ann_ex_ret = annualize_rets(excess_ret)
ann_vol = annualize_vol(r)
return (ann_ex_ret / ann_vol)
| 2,533,955,272,572,073,000
|
Computes the annualized sharpe ratio of a set of returns
|
kit.py
|
sharpe_ratio
|
jaimeaguilera/Investing-projects
|
python
|
def sharpe_ratio(r, riskfree_rate):
'\n \n '
r_valid = r[((r != 0) & r.notnull())]
total_num_periods = r_valid.count()
date_beg = r_valid.agg((lambda x: x.first_valid_index()))
date_end = r_valid.agg((lambda x: x.last_valid_index()))
try:
years_fraction = ((date_end - date_beg).dt.days / 365.2425)
except:
years_fraction = ((date_end - date_beg).days / 365.2425)
periods_per_year = (total_num_periods / years_fraction)
rf_per_period = (((1 + riskfree_rate) ** (1 / periods_per_year)) - 1)
excess_ret = (r - rf_per_period)
ann_ex_ret = annualize_rets(excess_ret)
ann_vol = annualize_vol(r)
return (ann_ex_ret / ann_vol)
|
def is_normal(r, level=0.01):
'\n Applies the Jarque-Bera test to determine if a Series is normal or not\n Test is applied at the 1% level by default\n Returns True if the hypothesis of normality is accepted, False otherwise\n '
if isinstance(r, pd.DataFrame):
return r.aggregate(is_normal)
else:
(statistic, p_value) = scipy.stats.jarque_bera(r)
return (p_value > level)
| 4,814,920,000,768,772,000
|
Applies the Jarque-Bera test to determine if a Series is normal or not
Test is applied at the 1% level by default
Returns True if the hypothesis of normality is accepted, False otherwise
|
kit.py
|
is_normal
|
jaimeaguilera/Investing-projects
|
python
|
def is_normal(r, level=0.01):
'\n Applies the Jarque-Bera test to determine if a Series is normal or not\n Test is applied at the 1% level by default\n Returns True if the hypothesis of normality is accepted, False otherwise\n '
if isinstance(r, pd.DataFrame):
return r.aggregate(is_normal)
else:
(statistic, p_value) = scipy.stats.jarque_bera(r)
return (p_value > level)
|
def drawdown(return_series: pd.Series):
'Takes a time series of asset returns.\n returns a DataFrame with columns for\n the wealth index, \n the previous peaks, and \n the percentage drawdown\n '
wealth_index = (1000 * (1 + return_series).cumprod())
previous_peaks = wealth_index.cummax()
drawdowns = ((wealth_index - previous_peaks) / previous_peaks)
return pd.DataFrame({'Wealth': wealth_index, 'Previous Peak': previous_peaks, 'Drawdown': drawdowns})
| 1,925,900,058,201,987,300
|
Takes a time series of asset returns.
returns a DataFrame with columns for
the wealth index,
the previous peaks, and
the percentage drawdown
|
kit.py
|
drawdown
|
jaimeaguilera/Investing-projects
|
python
|
def drawdown(return_series: pd.Series):
'Takes a time series of asset returns.\n returns a DataFrame with columns for\n the wealth index, \n the previous peaks, and \n the percentage drawdown\n '
wealth_index = (1000 * (1 + return_series).cumprod())
previous_peaks = wealth_index.cummax()
drawdowns = ((wealth_index - previous_peaks) / previous_peaks)
return pd.DataFrame({'Wealth': wealth_index, 'Previous Peak': previous_peaks, 'Drawdown': drawdowns})
|
def semideviation(r):
'\n Returns the semideviation aka negative semideviation of r\n r must be a Series or a DataFrame, else raises a TypeError\n '
if isinstance(r, pd.Series):
is_negative = (r < 0)
return r[is_negative].std(ddof=0)
elif isinstance(r, pd.DataFrame):
return r.aggregate(semideviation)
else:
raise TypeError('Expected r to be a Series or DataFrame')
| -1,785,064,964,747,070,700
|
Returns the semideviation aka negative semideviation of r
r must be a Series or a DataFrame, else raises a TypeError
|
kit.py
|
semideviation
|
jaimeaguilera/Investing-projects
|
python
|
def semideviation(r):
'\n Returns the semideviation aka negative semideviation of r\n r must be a Series or a DataFrame, else raises a TypeError\n '
if isinstance(r, pd.Series):
is_negative = (r < 0)
return r[is_negative].std(ddof=0)
elif isinstance(r, pd.DataFrame):
return r.aggregate(semideviation)
else:
raise TypeError('Expected r to be a Series or DataFrame')
|
def var_historic(r, level=5):
'\n Returns the historic Value at Risk at a specified level\n i.e. returns the number such that "level" percent of the returns\n fall below that number, and the (100-level) percent are above\n '
r = r[((r != 0) & r.notnull())]
if isinstance(r, pd.DataFrame):
return r.aggregate(var_historic, level=level)
elif isinstance(r, pd.Series):
return (- np.percentile(r, level))
else:
raise TypeError('Expected r to be a Series or DataFrame')
| 8,531,678,315,750,730,000
|
Returns the historic Value at Risk at a specified level
i.e. returns the number such that "level" percent of the returns
fall below that number, and the (100-level) percent are above
|
kit.py
|
var_historic
|
jaimeaguilera/Investing-projects
|
python
|
def var_historic(r, level=5):
'\n Returns the historic Value at Risk at a specified level\n i.e. returns the number such that "level" percent of the returns\n fall below that number, and the (100-level) percent are above\n '
r = r[((r != 0) & r.notnull())]
if isinstance(r, pd.DataFrame):
return r.aggregate(var_historic, level=level)
elif isinstance(r, pd.Series):
return (- np.percentile(r, level))
else:
raise TypeError('Expected r to be a Series or DataFrame')
|
def cvar_historic(r, level=5):
'\n Computes the Conditional VaR of Series or DataFrame\n '
r = r[((r != 0) & r.notnull())]
if isinstance(r, pd.Series):
is_beyond = (r <= (- var_historic(r, level=level)))
return (- r[is_beyond].mean())
elif isinstance(r, pd.DataFrame):
return r.aggregate(cvar_historic, level=level)
else:
raise TypeError('Expected r to be a Series or DataFrame')
| -3,315,997,735,787,485,000
|
Computes the Conditional VaR of Series or DataFrame
|
kit.py
|
cvar_historic
|
jaimeaguilera/Investing-projects
|
python
|
def cvar_historic(r, level=5):
'\n \n '
r = r[((r != 0) & r.notnull())]
if isinstance(r, pd.Series):
is_beyond = (r <= (- var_historic(r, level=level)))
return (- r[is_beyond].mean())
elif isinstance(r, pd.DataFrame):
return r.aggregate(cvar_historic, level=level)
else:
raise TypeError('Expected r to be a Series or DataFrame')
|
def var_gaussian(r, level=5, modified=False):
'\n Returns the Parametric Gauusian VaR of a Series or DataFrame\n If "modified" is True, then the modified VaR is returned,\n using the Cornish-Fisher modification\n '
r = r[((r != 0) & r.notnull())]
z = norm.ppf((level / 100))
if modified:
s = skewness(r)
k = kurtosis(r)
z = (((z + ((((z ** 2) - 1) * s) / 6)) + ((((z ** 3) - (3 * z)) * (k - 3)) / 24)) - ((((2 * (z ** 3)) - (5 * z)) * (s ** 2)) / 36))
return (- (r.mean() + (z * r.std(ddof=0))))
| 4,522,035,123,193,760,300
|
Returns the Parametric Gauusian VaR of a Series or DataFrame
If "modified" is True, then the modified VaR is returned,
using the Cornish-Fisher modification
|
kit.py
|
var_gaussian
|
jaimeaguilera/Investing-projects
|
python
|
def var_gaussian(r, level=5, modified=False):
'\n Returns the Parametric Gauusian VaR of a Series or DataFrame\n If "modified" is True, then the modified VaR is returned,\n using the Cornish-Fisher modification\n '
r = r[((r != 0) & r.notnull())]
z = norm.ppf((level / 100))
if modified:
s = skewness(r)
k = kurtosis(r)
z = (((z + ((((z ** 2) - 1) * s) / 6)) + ((((z ** 3) - (3 * z)) * (k - 3)) / 24)) - ((((2 * (z ** 3)) - (5 * z)) * (s ** 2)) / 36))
return (- (r.mean() + (z * r.std(ddof=0))))
|
def portfolio_return(weights, returns):
'\n Computes the return on a portfolio from constituent returns and weights\n weights are a numpy array or Nx1 matrix and returns are a numpy array or Nx1 matrix\n '
return (weights.T @ returns)
| -1,847,745,247,972,241,200
|
Computes the return on a portfolio from constituent returns and weights
weights are a numpy array or Nx1 matrix and returns are a numpy array or Nx1 matrix
|
kit.py
|
portfolio_return
|
jaimeaguilera/Investing-projects
|
python
|
def portfolio_return(weights, returns):
'\n Computes the return on a portfolio from constituent returns and weights\n weights are a numpy array or Nx1 matrix and returns are a numpy array or Nx1 matrix\n '
return (weights.T @ returns)
|
def portfolio_vol(weights, covmat):
'\n Computes the vol of a portfolio from a covariance matrix and constituent weights\n weights are a numpy array or N x 1 maxtrix and covmat is an N x N matrix\n '
vol = (((weights.T @ covmat) @ weights) ** 0.5)
return vol
| -3,955,678,057,595,877,400
|
Computes the vol of a portfolio from a covariance matrix and constituent weights
weights are a numpy array or N x 1 maxtrix and covmat is an N x N matrix
|
kit.py
|
portfolio_vol
|
jaimeaguilera/Investing-projects
|
python
|
def portfolio_vol(weights, covmat):
'\n Computes the vol of a portfolio from a covariance matrix and constituent weights\n weights are a numpy array or N x 1 maxtrix and covmat is an N x N matrix\n '
vol = (((weights.T @ covmat) @ weights) ** 0.5)
return vol
|
def plot_ef2(n_points, er, cov):
'\n Plots the 2-asset efficient frontier\n '
if ((er.shape[0] != 2) or (er.shape[0] != 2)):
raise ValueError('plot_ef2 can only plot 2-asset frontiers')
weights = [np.array([w, (1 - w)]) for w in np.linspace(0, 1, n_points)]
rets = [portfolio_return(w, er) for w in weights]
vols = [portfolio_vol(w, cov) for w in weights]
ef = pd.DataFrame({'Returns': rets, 'Volatility': vols})
return ef.plot.line(x='Volatility', y='Returns', style='.-')
| 6,113,814,886,680,996,000
|
Plots the 2-asset efficient frontier
|
kit.py
|
plot_ef2
|
jaimeaguilera/Investing-projects
|
python
|
def plot_ef2(n_points, er, cov):
'\n \n '
if ((er.shape[0] != 2) or (er.shape[0] != 2)):
raise ValueError('plot_ef2 can only plot 2-asset frontiers')
weights = [np.array([w, (1 - w)]) for w in np.linspace(0, 1, n_points)]
rets = [portfolio_return(w, er) for w in weights]
vols = [portfolio_vol(w, cov) for w in weights]
ef = pd.DataFrame({'Returns': rets, 'Volatility': vols})
return ef.plot.line(x='Volatility', y='Returns', style='.-')
|
def minimize_vol(target_return, er, cov):
'\n Returns the optimal weights that achieve the target return\n given a set of expected returns and a covariance matrix\n '
n = er.shape[0]
init_guess = np.repeat((1 / n), n)
bounds = (((0.0, 1.0),) * n)
weights_sum_to_1 = {'type': 'eq', 'fun': (lambda weights: (np.sum(weights) - 1))}
return_is_target = {'type': 'eq', 'args': (er,), 'fun': (lambda weights, er: (target_return - portfolio_return(weights, er)))}
weights = minimize(portfolio_vol, init_guess, args=(cov,), method='SLSQP', options={'disp': False}, constraints=(weights_sum_to_1, return_is_target), bounds=bounds)
return weights.x
| 7,147,474,082,142,541,000
|
Returns the optimal weights that achieve the target return
given a set of expected returns and a covariance matrix
|
kit.py
|
minimize_vol
|
jaimeaguilera/Investing-projects
|
python
|
def minimize_vol(target_return, er, cov):
'\n Returns the optimal weights that achieve the target return\n given a set of expected returns and a covariance matrix\n '
n = er.shape[0]
init_guess = np.repeat((1 / n), n)
bounds = (((0.0, 1.0),) * n)
weights_sum_to_1 = {'type': 'eq', 'fun': (lambda weights: (np.sum(weights) - 1))}
return_is_target = {'type': 'eq', 'args': (er,), 'fun': (lambda weights, er: (target_return - portfolio_return(weights, er)))}
weights = minimize(portfolio_vol, init_guess, args=(cov,), method='SLSQP', options={'disp': False}, constraints=(weights_sum_to_1, return_is_target), bounds=bounds)
return weights.x
|
def tracking_error(r_a, r_b):
'\n Returns the Tracking Error between the two return series\n '
return np.sqrt(((r_a - r_b) ** 2).sum())
| -6,295,209,354,440,144,000
|
Returns the Tracking Error between the two return series
|
kit.py
|
tracking_error
|
jaimeaguilera/Investing-projects
|
python
|
def tracking_error(r_a, r_b):
'\n \n '
return np.sqrt(((r_a - r_b) ** 2).sum())
|
def msr(riskfree_rate, er, cov):
'\n Returns the weights of the portfolio that gives you the maximum sharpe ratio\n given the riskfree rate and expected returns and a covariance matrix\n '
n = er.shape[0]
init_guess = np.repeat((1 / n), n)
bounds = (((0.0, 1.0),) * n)
weights_sum_to_1 = {'type': 'eq', 'fun': (lambda weights: (np.sum(weights) - 1))}
def neg_sharpe(weights, riskfree_rate, er, cov):
'\n Returns the negative of the sharpe ratio\n of the given portfolio\n '
r = portfolio_return(weights, er)
vol = portfolio_vol(weights, cov)
return ((- (r - riskfree_rate)) / vol)
weights = minimize(neg_sharpe, init_guess, args=(riskfree_rate, er, cov), method='SLSQP', options={'disp': False}, constraints=(weights_sum_to_1,), bounds=bounds)
return weights.x
| 3,631,754,018,628,217,300
|
Returns the weights of the portfolio that gives you the maximum sharpe ratio
given the riskfree rate and expected returns and a covariance matrix
|
kit.py
|
msr
|
jaimeaguilera/Investing-projects
|
python
|
def msr(riskfree_rate, er, cov):
'\n Returns the weights of the portfolio that gives you the maximum sharpe ratio\n given the riskfree rate and expected returns and a covariance matrix\n '
n = er.shape[0]
init_guess = np.repeat((1 / n), n)
bounds = (((0.0, 1.0),) * n)
weights_sum_to_1 = {'type': 'eq', 'fun': (lambda weights: (np.sum(weights) - 1))}
def neg_sharpe(weights, riskfree_rate, er, cov):
'\n Returns the negative of the sharpe ratio\n of the given portfolio\n '
r = portfolio_return(weights, er)
vol = portfolio_vol(weights, cov)
return ((- (r - riskfree_rate)) / vol)
weights = minimize(neg_sharpe, init_guess, args=(riskfree_rate, er, cov), method='SLSQP', options={'disp': False}, constraints=(weights_sum_to_1,), bounds=bounds)
return weights.x
|
def gmv(cov):
'\n Returns the weights of the Global Minimum Volatility portfolio\n given a covariance matrix\n '
n = cov.shape[0]
return msr(0, np.repeat(1, n), cov)
| 239,850,363,951,659,140
|
Returns the weights of the Global Minimum Volatility portfolio
given a covariance matrix
|
kit.py
|
gmv
|
jaimeaguilera/Investing-projects
|
python
|
def gmv(cov):
'\n Returns the weights of the Global Minimum Volatility portfolio\n given a covariance matrix\n '
n = cov.shape[0]
return msr(0, np.repeat(1, n), cov)
|
def optimal_weights(n_points, er, cov):
'\n Returns a list of weights that represent a grid of n_points on the efficient frontier\n '
target_rs = np.linspace(er.min(), er.max(), n_points)
weights = [minimize_vol(target_return, er, cov) for target_return in target_rs]
return weights
| -8,565,410,215,275,897,000
|
Returns a list of weights that represent a grid of n_points on the efficient frontier
|
kit.py
|
optimal_weights
|
jaimeaguilera/Investing-projects
|
python
|
def optimal_weights(n_points, er, cov):
'\n \n '
target_rs = np.linspace(er.min(), er.max(), n_points)
weights = [minimize_vol(target_return, er, cov) for target_return in target_rs]
return weights
|
def plot_ef(n_points, er, cov, style='.-', legend=False, show_cml=False, riskfree_rate=0, show_ew=False, show_gmv=False):
'\n Plots the multi-asset efficient frontier\n '
weights = optimal_weights(n_points, er, cov)
rets = [portfolio_return(w, er) for w in weights]
vols = [portfolio_vol(w, cov) for w in weights]
ef = pd.DataFrame({'Returns': rets, 'Volatility': vols})
ax = ef.plot.line(x='Volatility', y='Returns', style=style, legend=legend)
if show_cml:
ax.set_xlim(left=0)
w_msr = msr(riskfree_rate, er, cov)
r_msr = portfolio_return(w_msr, er)
vol_msr = portfolio_vol(w_msr, cov)
cml_x = [0, vol_msr]
cml_y = [riskfree_rate, r_msr]
ax.plot(cml_x, cml_y, color='green', marker='o', linestyle='dashed', linewidth=2, markersize=10)
if show_ew:
n = er.shape[0]
w_ew = np.repeat((1 / n), n)
r_ew = portfolio_return(w_ew, er)
vol_ew = portfolio_vol(w_ew, cov)
ax.plot([vol_ew], [r_ew], color='goldenrod', marker='o', markersize=10)
if show_gmv:
w_gmv = gmv(cov)
r_gmv = portfolio_return(w_gmv, er)
vol_gmv = portfolio_vol(w_gmv, cov)
ax.plot([vol_gmv], [r_gmv], color='midnightblue', marker='o', markersize=10)
return ax
| -588,327,934,387,513,900
|
Plots the multi-asset efficient frontier
|
kit.py
|
plot_ef
|
jaimeaguilera/Investing-projects
|
python
|
def plot_ef(n_points, er, cov, style='.-', legend=False, show_cml=False, riskfree_rate=0, show_ew=False, show_gmv=False):
'\n \n '
weights = optimal_weights(n_points, er, cov)
rets = [portfolio_return(w, er) for w in weights]
vols = [portfolio_vol(w, cov) for w in weights]
ef = pd.DataFrame({'Returns': rets, 'Volatility': vols})
ax = ef.plot.line(x='Volatility', y='Returns', style=style, legend=legend)
if show_cml:
ax.set_xlim(left=0)
w_msr = msr(riskfree_rate, er, cov)
r_msr = portfolio_return(w_msr, er)
vol_msr = portfolio_vol(w_msr, cov)
cml_x = [0, vol_msr]
cml_y = [riskfree_rate, r_msr]
ax.plot(cml_x, cml_y, color='green', marker='o', linestyle='dashed', linewidth=2, markersize=10)
if show_ew:
n = er.shape[0]
w_ew = np.repeat((1 / n), n)
r_ew = portfolio_return(w_ew, er)
vol_ew = portfolio_vol(w_ew, cov)
ax.plot([vol_ew], [r_ew], color='goldenrod', marker='o', markersize=10)
if show_gmv:
w_gmv = gmv(cov)
r_gmv = portfolio_return(w_gmv, er)
vol_gmv = portfolio_vol(w_gmv, cov)
ax.plot([vol_gmv], [r_gmv], color='midnightblue', marker='o', markersize=10)
return ax
|
def run_cppi(risky_r, safe_r=None, m=3, start=1000, floor=0.8, riskfree_rate=0.03, drawdown=None):
'\n Run a backtest of the CPPI strategy, given a set of returns for the risky asset\n Returns a dictionary containing: Asset Value History, Risk Budget History, Risky Weight History\n '
dates = risky_r.index
n_steps = len(dates)
account_value = start
floor_value = (start * floor)
peak = account_value
if isinstance(risky_r, pd.Series):
risky_r = pd.DataFrame(risky_r, columns=['R'])
if (safe_r is None):
safe_r = pd.DataFrame().reindex_like(risky_r)
safe_r.values[:] = (riskfree_rate / 12)
account_history = pd.DataFrame().reindex_like(risky_r)
risky_w_history = pd.DataFrame().reindex_like(risky_r)
cushion_history = pd.DataFrame().reindex_like(risky_r)
floorval_history = pd.DataFrame().reindex_like(risky_r)
peak_history = pd.DataFrame().reindex_like(risky_r)
for step in range(n_steps):
if (drawdown is not None):
peak = np.maximum(peak, account_value)
floor_value = (peak * (1 - drawdown))
cushion = ((account_value - floor_value) / account_value)
risky_w = (m * cushion)
risky_w = np.minimum(risky_w, 1)
risky_w = np.maximum(risky_w, 0)
safe_w = (1 - risky_w)
risky_alloc = (account_value * risky_w)
safe_alloc = (account_value * safe_w)
account_value = ((risky_alloc * (1 + risky_r.iloc[step])) + (safe_alloc * (1 + safe_r.iloc[step])))
cushion_history.iloc[step] = cushion
risky_w_history.iloc[step] = risky_w
account_history.iloc[step] = account_value
floorval_history.iloc[step] = floor_value
peak_history.iloc[step] = peak
risky_wealth = (start * (1 + risky_r).cumprod())
backtest_result = {'Wealth': account_history, 'Risky Wealth': risky_wealth, 'Risk Budget': cushion_history, 'Risky Allocation': risky_w_history, 'm': m, 'start': start, 'floor': floor, 'risky_r': risky_r, 'safe_r': safe_r, 'drawdown': drawdown, 'peak': peak_history, 'floor': floorval_history}
return backtest_result
| 1,973,406,296,599,866,400
|
Run a backtest of the CPPI strategy, given a set of returns for the risky asset
Returns a dictionary containing: Asset Value History, Risk Budget History, Risky Weight History
|
kit.py
|
run_cppi
|
jaimeaguilera/Investing-projects
|
python
|
def run_cppi(risky_r, safe_r=None, m=3, start=1000, floor=0.8, riskfree_rate=0.03, drawdown=None):
'\n Run a backtest of the CPPI strategy, given a set of returns for the risky asset\n Returns a dictionary containing: Asset Value History, Risk Budget History, Risky Weight History\n '
dates = risky_r.index
n_steps = len(dates)
account_value = start
floor_value = (start * floor)
peak = account_value
if isinstance(risky_r, pd.Series):
risky_r = pd.DataFrame(risky_r, columns=['R'])
if (safe_r is None):
safe_r = pd.DataFrame().reindex_like(risky_r)
safe_r.values[:] = (riskfree_rate / 12)
account_history = pd.DataFrame().reindex_like(risky_r)
risky_w_history = pd.DataFrame().reindex_like(risky_r)
cushion_history = pd.DataFrame().reindex_like(risky_r)
floorval_history = pd.DataFrame().reindex_like(risky_r)
peak_history = pd.DataFrame().reindex_like(risky_r)
for step in range(n_steps):
if (drawdown is not None):
peak = np.maximum(peak, account_value)
floor_value = (peak * (1 - drawdown))
cushion = ((account_value - floor_value) / account_value)
risky_w = (m * cushion)
risky_w = np.minimum(risky_w, 1)
risky_w = np.maximum(risky_w, 0)
safe_w = (1 - risky_w)
risky_alloc = (account_value * risky_w)
safe_alloc = (account_value * safe_w)
account_value = ((risky_alloc * (1 + risky_r.iloc[step])) + (safe_alloc * (1 + safe_r.iloc[step])))
cushion_history.iloc[step] = cushion
risky_w_history.iloc[step] = risky_w
account_history.iloc[step] = account_value
floorval_history.iloc[step] = floor_value
peak_history.iloc[step] = peak
risky_wealth = (start * (1 + risky_r).cumprod())
backtest_result = {'Wealth': account_history, 'Risky Wealth': risky_wealth, 'Risk Budget': cushion_history, 'Risky Allocation': risky_w_history, 'm': m, 'start': start, 'floor': floor, 'risky_r': risky_r, 'safe_r': safe_r, 'drawdown': drawdown, 'peak': peak_history, 'floor': floorval_history}
return backtest_result
|
def summary_stats(r, riskfree_rate=0.03):
'\n Return a DataFrame that contains aggregated summary stats for the returns in the columns of r\n '
ann_r = annualize_rets(r)
ann_vol = annualize_vol(r)
ann_sr = sharpe_ratio(r, riskfree_rate=riskfree_rate)
dd = r.aggregate((lambda r: drawdown(r).Drawdown.min()))
skew = r.aggregate(skewness)
kurt = r.aggregate(kurtosis)
cf_var5 = r.aggregate(var_gaussian, modified=True)
hist_cvar5 = r.aggregate(cvar_historic)
return pd.DataFrame({'Annualized Return': ann_r, 'Annualized Vol': ann_vol, 'Skewness': skew, 'Kurtosis': kurt, 'Cornish-Fisher VaR (5%)': cf_var5, 'Historic CVaR (5%)': hist_cvar5, 'Sharpe Ratio': ann_sr, 'Max Drawdown': dd})
| -3,695,334,458,142,436,400
|
Return a DataFrame that contains aggregated summary stats for the returns in the columns of r
|
kit.py
|
summary_stats
|
jaimeaguilera/Investing-projects
|
python
|
def summary_stats(r, riskfree_rate=0.03):
'\n \n '
ann_r = annualize_rets(r)
ann_vol = annualize_vol(r)
ann_sr = sharpe_ratio(r, riskfree_rate=riskfree_rate)
dd = r.aggregate((lambda r: drawdown(r).Drawdown.min()))
skew = r.aggregate(skewness)
kurt = r.aggregate(kurtosis)
cf_var5 = r.aggregate(var_gaussian, modified=True)
hist_cvar5 = r.aggregate(cvar_historic)
return pd.DataFrame({'Annualized Return': ann_r, 'Annualized Vol': ann_vol, 'Skewness': skew, 'Kurtosis': kurt, 'Cornish-Fisher VaR (5%)': cf_var5, 'Historic CVaR (5%)': hist_cvar5, 'Sharpe Ratio': ann_sr, 'Max Drawdown': dd})
|
def gbm(n_years=10, n_scenarios=1000, mu=0.07, sigma=0.15, steps_per_year=12, s_0=100.0, prices=True):
'\n Evolution of Geometric Brownian Motion trajectories, such as for Stock Prices through Monte Carlo\n :param n_years: The number of years to generate data for\n :param n_paths: The number of scenarios/trajectories\n :param mu: Annualized Drift, e.g. Market Return\n :param sigma: Annualized Volatility\n :param steps_per_year: granularity of the simulation\n :param s_0: initial value\n :return: a numpy array of n_paths columns and n_years*steps_per_year rows\n '
dt = (1 / steps_per_year)
n_steps = (int((n_years * steps_per_year)) + 1)
rets_plus_1 = np.random.normal(loc=((1 + mu) ** dt), scale=(sigma * np.sqrt(dt)), size=(n_steps, n_scenarios))
rets_plus_1[0] = 1
ret_val = ((s_0 * pd.DataFrame(rets_plus_1).cumprod()) if prices else (rets_plus_1 - 1))
return ret_val
| -5,941,378,999,358,949,000
|
Evolution of Geometric Brownian Motion trajectories, such as for Stock Prices through Monte Carlo
:param n_years: The number of years to generate data for
:param n_paths: The number of scenarios/trajectories
:param mu: Annualized Drift, e.g. Market Return
:param sigma: Annualized Volatility
:param steps_per_year: granularity of the simulation
:param s_0: initial value
:return: a numpy array of n_paths columns and n_years*steps_per_year rows
|
kit.py
|
gbm
|
jaimeaguilera/Investing-projects
|
python
|
def gbm(n_years=10, n_scenarios=1000, mu=0.07, sigma=0.15, steps_per_year=12, s_0=100.0, prices=True):
'\n Evolution of Geometric Brownian Motion trajectories, such as for Stock Prices through Monte Carlo\n :param n_years: The number of years to generate data for\n :param n_paths: The number of scenarios/trajectories\n :param mu: Annualized Drift, e.g. Market Return\n :param sigma: Annualized Volatility\n :param steps_per_year: granularity of the simulation\n :param s_0: initial value\n :return: a numpy array of n_paths columns and n_years*steps_per_year rows\n '
dt = (1 / steps_per_year)
n_steps = (int((n_years * steps_per_year)) + 1)
rets_plus_1 = np.random.normal(loc=((1 + mu) ** dt), scale=(sigma * np.sqrt(dt)), size=(n_steps, n_scenarios))
rets_plus_1[0] = 1
ret_val = ((s_0 * pd.DataFrame(rets_plus_1).cumprod()) if prices else (rets_plus_1 - 1))
return ret_val
|
def regress(dependent_variable, explanatory_variables, alpha=True):
"\n Runs a linear regression to decompose the dependent variable into the explanatory variables\n returns an object of type statsmodel's RegressionResults on which you can call\n .summary() to print a full summary\n .params for the coefficients\n .tvalues and .pvalues for the significance levels\n .rsquared_adj and .rsquared for quality of fit\n "
if alpha:
explanatory_variables = explanatory_variables.copy()
explanatory_variables['Alpha'] = 1
lm = sm.OLS(dependent_variable, explanatory_variables).fit()
return lm
| -2,629,055,977,376,220,700
|
Runs a linear regression to decompose the dependent variable into the explanatory variables
returns an object of type statsmodel's RegressionResults on which you can call
.summary() to print a full summary
.params for the coefficients
.tvalues and .pvalues for the significance levels
.rsquared_adj and .rsquared for quality of fit
|
kit.py
|
regress
|
jaimeaguilera/Investing-projects
|
python
|
def regress(dependent_variable, explanatory_variables, alpha=True):
"\n Runs a linear regression to decompose the dependent variable into the explanatory variables\n returns an object of type statsmodel's RegressionResults on which you can call\n .summary() to print a full summary\n .params for the coefficients\n .tvalues and .pvalues for the significance levels\n .rsquared_adj and .rsquared for quality of fit\n "
if alpha:
explanatory_variables = explanatory_variables.copy()
explanatory_variables['Alpha'] = 1
lm = sm.OLS(dependent_variable, explanatory_variables).fit()
return lm
|
def portfolio_tracking_error(weights, ref_r, bb_r):
'\n returns the tracking error between the reference returns\n and a portfolio of building block returns held with given weights\n '
return tracking_error(ref_r, (weights * bb_r).sum(axis=1))
| -5,504,051,318,243,047,000
|
returns the tracking error between the reference returns
and a portfolio of building block returns held with given weights
|
kit.py
|
portfolio_tracking_error
|
jaimeaguilera/Investing-projects
|
python
|
def portfolio_tracking_error(weights, ref_r, bb_r):
'\n returns the tracking error between the reference returns\n and a portfolio of building block returns held with given weights\n '
return tracking_error(ref_r, (weights * bb_r).sum(axis=1))
|
def style_analysis(dependent_variable, explanatory_variables):
'\n Returns the optimal weights that minimizes the Tracking error between\n a portfolio of the explanatory variables and the dependent variable\n '
n = explanatory_variables.shape[1]
init_guess = np.repeat((1 / n), n)
bounds = (((0.0, 1.0),) * n)
weights_sum_to_1 = {'type': 'eq', 'fun': (lambda weights: (np.sum(weights) - 1))}
solution = minimize(portfolio_tracking_error, init_guess, args=(dependent_variable, explanatory_variables), method='SLSQP', options={'disp': False}, constraints=(weights_sum_to_1,), bounds=bounds)
weights = pd.Series(solution.x, index=explanatory_variables.columns)
return weights
| -7,954,644,322,848,577,000
|
Returns the optimal weights that minimizes the Tracking error between
a portfolio of the explanatory variables and the dependent variable
|
kit.py
|
style_analysis
|
jaimeaguilera/Investing-projects
|
python
|
def style_analysis(dependent_variable, explanatory_variables):
'\n Returns the optimal weights that minimizes the Tracking error between\n a portfolio of the explanatory variables and the dependent variable\n '
n = explanatory_variables.shape[1]
init_guess = np.repeat((1 / n), n)
bounds = (((0.0, 1.0),) * n)
weights_sum_to_1 = {'type': 'eq', 'fun': (lambda weights: (np.sum(weights) - 1))}
solution = minimize(portfolio_tracking_error, init_guess, args=(dependent_variable, explanatory_variables), method='SLSQP', options={'disp': False}, constraints=(weights_sum_to_1,), bounds=bounds)
weights = pd.Series(solution.x, index=explanatory_variables.columns)
return weights
|
def ff_analysis(r, factors):
'\n Returns the loadings of r on the Fama French Factors\n which can be read in using get_fff_returns()\n the index of r must be a (not necessarily proper) subset of the index of factors\n r is either a Series or a DataFrame\n '
if isinstance(r, pd.Series):
dependent_variable = r
explanatory_variables = factors.loc[r.index]
tilts = regress(dependent_variable, explanatory_variables).params
elif isinstance(r, pd.DataFrame):
tilts = pd.DataFrame({col: ff_analysis(r[col], factors) for col in r.columns})
else:
raise TypeError('r must be a Series or a DataFrame')
return tilts
| 5,331,380,417,579,062,000
|
Returns the loadings of r on the Fama French Factors
which can be read in using get_fff_returns()
the index of r must be a (not necessarily proper) subset of the index of factors
r is either a Series or a DataFrame
|
kit.py
|
ff_analysis
|
jaimeaguilera/Investing-projects
|
python
|
def ff_analysis(r, factors):
'\n Returns the loadings of r on the Fama French Factors\n which can be read in using get_fff_returns()\n the index of r must be a (not necessarily proper) subset of the index of factors\n r is either a Series or a DataFrame\n '
if isinstance(r, pd.Series):
dependent_variable = r
explanatory_variables = factors.loc[r.index]
tilts = regress(dependent_variable, explanatory_variables).params
elif isinstance(r, pd.DataFrame):
tilts = pd.DataFrame({col: ff_analysis(r[col], factors) for col in r.columns})
else:
raise TypeError('r must be a Series or a DataFrame')
return tilts
|
def weight_ew(r, cap_weights=None, max_cw_mult=None, microcap_threshold=None, **kwargs):
'\n Returns the weights of the EW portfolio based on the asset returns "r" as a DataFrame\n If supplied a set of capweights and a capweight tether, it is applied and reweighted \n '
n = len(r.columns)
ew = pd.Series((1 / n), index=r.columns)
if (cap_weights is not None):
cw = cap_weights.loc[r.index[0]]
if ((microcap_threshold is not None) and (microcap_threshold > 0)):
microcap = (cw < microcap_threshold)
ew[microcap] = 0
ew = (ew / ew.sum())
if ((max_cw_mult is not None) and (max_cw_mult > 0)):
ew = np.minimum(ew, (cw * max_cw_mult))
ew = (ew / ew.sum())
return ew
| 8,770,652,885,608,347,000
|
Returns the weights of the EW portfolio based on the asset returns "r" as a DataFrame
If supplied a set of capweights and a capweight tether, it is applied and reweighted
|
kit.py
|
weight_ew
|
jaimeaguilera/Investing-projects
|
python
|
def weight_ew(r, cap_weights=None, max_cw_mult=None, microcap_threshold=None, **kwargs):
'\n Returns the weights of the EW portfolio based on the asset returns "r" as a DataFrame\n If supplied a set of capweights and a capweight tether, it is applied and reweighted \n '
n = len(r.columns)
ew = pd.Series((1 / n), index=r.columns)
if (cap_weights is not None):
cw = cap_weights.loc[r.index[0]]
if ((microcap_threshold is not None) and (microcap_threshold > 0)):
microcap = (cw < microcap_threshold)
ew[microcap] = 0
ew = (ew / ew.sum())
if ((max_cw_mult is not None) and (max_cw_mult > 0)):
ew = np.minimum(ew, (cw * max_cw_mult))
ew = (ew / ew.sum())
return ew
|
def weight_cw(r, cap_weights, **kwargs):
'\n Returns the weights of the CW portfolio based on the time series of capweights\n '
w = cap_weights.loc[r.index[1]]
return (w / w.sum())
| 345,298,233,300,992,060
|
Returns the weights of the CW portfolio based on the time series of capweights
|
kit.py
|
weight_cw
|
jaimeaguilera/Investing-projects
|
python
|
def weight_cw(r, cap_weights, **kwargs):
'\n \n '
w = cap_weights.loc[r.index[1]]
return (w / w.sum())
|
def backtest_ws(r, estimation_window=60, weighting=weight_ew, verbose=False, **kwargs):
'\n Backtests a given weighting scheme, given some parameters:\n r : asset returns to use to build the portfolio\n estimation_window: the window to use to estimate parameters\n weighting: the weighting scheme to use, must be a function that takes "r", and a variable number of keyword-value arguments\n '
n_periods = r.shape[0]
windows = [(start, (start + estimation_window)) for start in range((n_periods - estimation_window))]
weights = [weighting(r.iloc[win[0]:win[1]], **kwargs) for win in windows]
weights = pd.DataFrame(weights, index=r.iloc[estimation_window:].index, columns=r.columns)
returns = (weights * r).sum(axis='columns', min_count=1)
return returns
| 4,342,074,272,339,228,000
|
Backtests a given weighting scheme, given some parameters:
r : asset returns to use to build the portfolio
estimation_window: the window to use to estimate parameters
weighting: the weighting scheme to use, must be a function that takes "r", and a variable number of keyword-value arguments
|
kit.py
|
backtest_ws
|
jaimeaguilera/Investing-projects
|
python
|
def backtest_ws(r, estimation_window=60, weighting=weight_ew, verbose=False, **kwargs):
'\n Backtests a given weighting scheme, given some parameters:\n r : asset returns to use to build the portfolio\n estimation_window: the window to use to estimate parameters\n weighting: the weighting scheme to use, must be a function that takes "r", and a variable number of keyword-value arguments\n '
n_periods = r.shape[0]
windows = [(start, (start + estimation_window)) for start in range((n_periods - estimation_window))]
weights = [weighting(r.iloc[win[0]:win[1]], **kwargs) for win in windows]
weights = pd.DataFrame(weights, index=r.iloc[estimation_window:].index, columns=r.columns)
returns = (weights * r).sum(axis='columns', min_count=1)
return returns
|
def sample_cov(r, **kwargs):
'\n Returns the sample covariance of the supplied returns\n '
return r.cov()
| 3,398,896,989,843,861,500
|
Returns the sample covariance of the supplied returns
|
kit.py
|
sample_cov
|
jaimeaguilera/Investing-projects
|
python
|
def sample_cov(r, **kwargs):
'\n \n '
return r.cov()
|
def weight_gmv(r, cov_estimator=sample_cov, **kwargs):
'\n Produces the weights of the GMV portfolio given a covariance matrix of the returns \n '
est_cov = cov_estimator(r, **kwargs)
return gmv(est_cov)
| -4,044,872,262,371,711,500
|
Produces the weights of the GMV portfolio given a covariance matrix of the returns
|
kit.py
|
weight_gmv
|
jaimeaguilera/Investing-projects
|
python
|
def weight_gmv(r, cov_estimator=sample_cov, **kwargs):
'\n \n '
est_cov = cov_estimator(r, **kwargs)
return gmv(est_cov)
|
def cc_cov(r, **kwargs):
'\n Estimates a covariance matrix by using the Elton/Gruber Constant Correlation model\n '
rhos = r.corr()
n = rhos.shape[0]
rho_bar = ((rhos.values.sum() - n) / (n * (n - 1)))
ccor = np.full_like(rhos, rho_bar)
np.fill_diagonal(ccor, 1.0)
sd = r.std()
return pd.DataFrame((ccor * np.outer(sd, sd)), index=r.columns, columns=r.columns)
| -2,987,201,178,320,407,000
|
Estimates a covariance matrix by using the Elton/Gruber Constant Correlation model
|
kit.py
|
cc_cov
|
jaimeaguilera/Investing-projects
|
python
|
def cc_cov(r, **kwargs):
'\n \n '
rhos = r.corr()
n = rhos.shape[0]
rho_bar = ((rhos.values.sum() - n) / (n * (n - 1)))
ccor = np.full_like(rhos, rho_bar)
np.fill_diagonal(ccor, 1.0)
sd = r.std()
return pd.DataFrame((ccor * np.outer(sd, sd)), index=r.columns, columns=r.columns)
|
def shrinkage_cov(r, delta=0.5, **kwargs):
'\n Covariance estimator that shrinks between the Sample Covariance and the Constant Correlation Estimators\n '
prior = cc_cov(r, **kwargs)
sample = sample_cov(r, **kwargs)
return ((delta * prior) + ((1 - delta) * sample))
| 7,209,318,898,781,462,000
|
Covariance estimator that shrinks between the Sample Covariance and the Constant Correlation Estimators
|
kit.py
|
shrinkage_cov
|
jaimeaguilera/Investing-projects
|
python
|
def shrinkage_cov(r, delta=0.5, **kwargs):
'\n \n '
prior = cc_cov(r, **kwargs)
sample = sample_cov(r, **kwargs)
return ((delta * prior) + ((1 - delta) * sample))
|
def risk_contribution(w, cov):
'\n Compute the contributions to risk of the constituents of a portfolio, given a set of portfolio weights and a covariance matrix\n '
total_portfolio_var = (portfolio_vol(w, cov) ** 2)
marginal_contrib = (cov @ w)
risk_contrib = (np.multiply(marginal_contrib, w.T) / total_portfolio_var)
return risk_contrib
| 499,167,234,481,604,100
|
Compute the contributions to risk of the constituents of a portfolio, given a set of portfolio weights and a covariance matrix
|
kit.py
|
risk_contribution
|
jaimeaguilera/Investing-projects
|
python
|
def risk_contribution(w, cov):
'\n \n '
total_portfolio_var = (portfolio_vol(w, cov) ** 2)
marginal_contrib = (cov @ w)
risk_contrib = (np.multiply(marginal_contrib, w.T) / total_portfolio_var)
return risk_contrib
|
def target_risk_contributions(target_risk, cov):
'\n Returns the weights of the portfolio that gives you the weights such\n that the contributions to portfolio risk are as close as possible to\n the target_risk, given the covariance matrix\n '
n = cov.shape[0]
init_guess = np.repeat((1 / n), n)
bounds = (((0.0, 1.0),) * n)
weights_sum_to_1 = {'type': 'eq', 'fun': (lambda weights: (np.sum(weights) - 1))}
def msd_risk(weights, target_risk, cov):
'\n Returns the Mean Squared Difference in risk contributions\n between weights and target_risk\n '
w_contribs = risk_contribution(weights, cov)
return ((w_contribs - target_risk) ** 2).sum()
weights = minimize(msd_risk, init_guess, args=(target_risk, cov), method='SLSQP', options={'disp': False}, constraints=(weights_sum_to_1,), bounds=bounds)
return weights.x
| -6,586,840,443,301,521,000
|
Returns the weights of the portfolio that gives you the weights such
that the contributions to portfolio risk are as close as possible to
the target_risk, given the covariance matrix
|
kit.py
|
target_risk_contributions
|
jaimeaguilera/Investing-projects
|
python
|
def target_risk_contributions(target_risk, cov):
'\n Returns the weights of the portfolio that gives you the weights such\n that the contributions to portfolio risk are as close as possible to\n the target_risk, given the covariance matrix\n '
n = cov.shape[0]
init_guess = np.repeat((1 / n), n)
bounds = (((0.0, 1.0),) * n)
weights_sum_to_1 = {'type': 'eq', 'fun': (lambda weights: (np.sum(weights) - 1))}
def msd_risk(weights, target_risk, cov):
'\n Returns the Mean Squared Difference in risk contributions\n between weights and target_risk\n '
w_contribs = risk_contribution(weights, cov)
return ((w_contribs - target_risk) ** 2).sum()
weights = minimize(msd_risk, init_guess, args=(target_risk, cov), method='SLSQP', options={'disp': False}, constraints=(weights_sum_to_1,), bounds=bounds)
return weights.x
|
def equal_risk_contributions(cov):
'\n Returns the weights of the portfolio that equalizes the contributions\n of the constituents based on the given covariance matrix\n '
n = cov.shape[0]
return target_risk_contributions(target_risk=np.repeat((1 / n), n), cov=cov)
| -4,143,323,565,454,961,700
|
Returns the weights of the portfolio that equalizes the contributions
of the constituents based on the given covariance matrix
|
kit.py
|
equal_risk_contributions
|
jaimeaguilera/Investing-projects
|
python
|
def equal_risk_contributions(cov):
'\n Returns the weights of the portfolio that equalizes the contributions\n of the constituents based on the given covariance matrix\n '
n = cov.shape[0]
return target_risk_contributions(target_risk=np.repeat((1 / n), n), cov=cov)
|
def weight_erc(r, cov_estimator=sample_cov, **kwargs):
'\n Produces the weights of the ERC portfolio given a covariance matrix of the returns \n '
est_cov = cov_estimator(r, **kwargs)
return equal_risk_contributions(est_cov)
| 1,028,696,242,090,410,500
|
Produces the weights of the ERC portfolio given a covariance matrix of the returns
|
kit.py
|
weight_erc
|
jaimeaguilera/Investing-projects
|
python
|
def weight_erc(r, cov_estimator=sample_cov, **kwargs):
'\n \n '
est_cov = cov_estimator(r, **kwargs)
return equal_risk_contributions(est_cov)
|
def implied_returns(delta, sigma, w):
'\nObtain the implied expected returns by reverse engineering the weights\nInputs:\ndelta: Risk Aversion Coefficient (scalar)\nsigma: Variance-Covariance Matrix (N x N) as DataFrame\n w: Portfolio weights (N x 1) as Series\nReturns an N x 1 vector of Returns as Series\n '
ir = (delta * sigma.dot(w).squeeze())
ir.name = 'Implied Returns'
return ir
| -2,040,071,156,509,215,700
|
Obtain the implied expected returns by reverse engineering the weights
Inputs:
delta: Risk Aversion Coefficient (scalar)
sigma: Variance-Covariance Matrix (N x N) as DataFrame
w: Portfolio weights (N x 1) as Series
Returns an N x 1 vector of Returns as Series
|
kit.py
|
implied_returns
|
jaimeaguilera/Investing-projects
|
python
|
def implied_returns(delta, sigma, w):
'\nObtain the implied expected returns by reverse engineering the weights\nInputs:\ndelta: Risk Aversion Coefficient (scalar)\nsigma: Variance-Covariance Matrix (N x N) as DataFrame\n w: Portfolio weights (N x 1) as Series\nReturns an N x 1 vector of Returns as Series\n '
ir = (delta * sigma.dot(w).squeeze())
ir.name = 'Implied Returns'
return ir
|
def proportional_prior(sigma, tau, p):
'\n Returns the He-Litterman simplified Omega\n Inputs:\n sigma: N x N Covariance Matrix as DataFrame\n tau: a scalar\n p: a K x N DataFrame linking Q and Assets\n returns a P x P DataFrame, a Matrix representing Prior Uncertainties\n '
helit_omega = p.dot((tau * sigma)).dot(p.T)
return pd.DataFrame(np.diag(np.diag(helit_omega.values)), index=p.index, columns=p.index)
| -3,693,253,497,267,448,300
|
Returns the He-Litterman simplified Omega
Inputs:
sigma: N x N Covariance Matrix as DataFrame
tau: a scalar
p: a K x N DataFrame linking Q and Assets
returns a P x P DataFrame, a Matrix representing Prior Uncertainties
|
kit.py
|
proportional_prior
|
jaimeaguilera/Investing-projects
|
python
|
def proportional_prior(sigma, tau, p):
'\n Returns the He-Litterman simplified Omega\n Inputs:\n sigma: N x N Covariance Matrix as DataFrame\n tau: a scalar\n p: a K x N DataFrame linking Q and Assets\n returns a P x P DataFrame, a Matrix representing Prior Uncertainties\n '
helit_omega = p.dot((tau * sigma)).dot(p.T)
return pd.DataFrame(np.diag(np.diag(helit_omega.values)), index=p.index, columns=p.index)
|
def bl(w_prior, sigma_prior, p, q, omega=None, delta=2.5, tau=0.02):
'\n# Computes the posterior expected returns based on \n# the original black litterman reference model\n#\n# W.prior must be an N x 1 vector of weights, a Series\n# Sigma.prior is an N x N covariance matrix, a DataFrame\n# P must be a K x N matrix linking Q and the Assets, a DataFrame\n# Q must be an K x 1 vector of views, a Series\n# Omega must be a K x K matrix a DataFrame, or None\n# if Omega is None, we assume it is\n# proportional to variance of the prior\n# delta and tau are scalars\n '
if (omega is None):
omega = proportional_prior(sigma_prior, tau, p)
N = w_prior.shape[0]
K = q.shape[0]
pi = implied_returns(delta, sigma_prior, w_prior)
sigma_prior_scaled = (tau * sigma_prior)
mu_bl = (pi + sigma_prior_scaled.dot(p.T).dot(inv((p.dot(sigma_prior_scaled).dot(p.T) + omega)).dot((q - p.dot(pi).values))))
sigma_bl = ((sigma_prior + sigma_prior_scaled) - sigma_prior_scaled.dot(p.T).dot(inv((p.dot(sigma_prior_scaled).dot(p.T) + omega))).dot(p).dot(sigma_prior_scaled))
return (mu_bl, sigma_bl)
| -185,691,400,770,407,680
|
# Computes the posterior expected returns based on
# the original black litterman reference model
#
# W.prior must be an N x 1 vector of weights, a Series
# Sigma.prior is an N x N covariance matrix, a DataFrame
# P must be a K x N matrix linking Q and the Assets, a DataFrame
# Q must be an K x 1 vector of views, a Series
# Omega must be a K x K matrix a DataFrame, or None
# if Omega is None, we assume it is
# proportional to variance of the prior
# delta and tau are scalars
|
kit.py
|
bl
|
jaimeaguilera/Investing-projects
|
python
|
def bl(w_prior, sigma_prior, p, q, omega=None, delta=2.5, tau=0.02):
'\n# Computes the posterior expected returns based on \n# the original black litterman reference model\n#\n# W.prior must be an N x 1 vector of weights, a Series\n# Sigma.prior is an N x N covariance matrix, a DataFrame\n# P must be a K x N matrix linking Q and the Assets, a DataFrame\n# Q must be an K x 1 vector of views, a Series\n# Omega must be a K x K matrix a DataFrame, or None\n# if Omega is None, we assume it is\n# proportional to variance of the prior\n# delta and tau are scalars\n '
if (omega is None):
omega = proportional_prior(sigma_prior, tau, p)
N = w_prior.shape[0]
K = q.shape[0]
pi = implied_returns(delta, sigma_prior, w_prior)
sigma_prior_scaled = (tau * sigma_prior)
mu_bl = (pi + sigma_prior_scaled.dot(p.T).dot(inv((p.dot(sigma_prior_scaled).dot(p.T) + omega)).dot((q - p.dot(pi).values))))
sigma_bl = ((sigma_prior + sigma_prior_scaled) - sigma_prior_scaled.dot(p.T).dot(inv((p.dot(sigma_prior_scaled).dot(p.T) + omega))).dot(p).dot(sigma_prior_scaled))
return (mu_bl, sigma_bl)
|
def inverse(d):
'\n Invert the dataframe by inverting the underlying matrix\n '
return pd.DataFrame(inv(d.values), index=d.columns, columns=d.index)
| -3,257,535,559,224,084,500
|
Invert the dataframe by inverting the underlying matrix
|
kit.py
|
inverse
|
jaimeaguilera/Investing-projects
|
python
|
def inverse(d):
'\n \n '
return pd.DataFrame(inv(d.values), index=d.columns, columns=d.index)
|
def weight_msr(sigma, mu, scale=True):
'\n Optimal (Tangent/Max Sharpe Ratio) Portfolio weights\n by using the Markowitz Optimization Procedure\n Mu is the vector of Excess expected Returns\n Sigma must be an N x N matrix as a DataFrame and Mu a column vector as a Series\n This implements page 188 Equation 5.2.28 of\n "The econometrics of financial markets" Campbell, Lo and Mackinlay.\n '
w = inverse(sigma).dot(mu)
if scale:
w = (w / sum(w))
return w
| 1,760,906,879,167,205,600
|
Optimal (Tangent/Max Sharpe Ratio) Portfolio weights
by using the Markowitz Optimization Procedure
Mu is the vector of Excess expected Returns
Sigma must be an N x N matrix as a DataFrame and Mu a column vector as a Series
This implements page 188 Equation 5.2.28 of
"The econometrics of financial markets" Campbell, Lo and Mackinlay.
|
kit.py
|
weight_msr
|
jaimeaguilera/Investing-projects
|
python
|
def weight_msr(sigma, mu, scale=True):
'\n Optimal (Tangent/Max Sharpe Ratio) Portfolio weights\n by using the Markowitz Optimization Procedure\n Mu is the vector of Excess expected Returns\n Sigma must be an N x N matrix as a DataFrame and Mu a column vector as a Series\n This implements page 188 Equation 5.2.28 of\n "The econometrics of financial markets" Campbell, Lo and Mackinlay.\n '
w = inverse(sigma).dot(mu)
if scale:
w = (w / sum(w))
return w
|
def neg_sharpe(weights, riskfree_rate, er, cov):
'\n Returns the negative of the sharpe ratio\n of the given portfolio\n '
r = portfolio_return(weights, er)
vol = portfolio_vol(weights, cov)
return ((- (r - riskfree_rate)) / vol)
| -5,140,026,034,260,675,000
|
Returns the negative of the sharpe ratio
of the given portfolio
|
kit.py
|
neg_sharpe
|
jaimeaguilera/Investing-projects
|
python
|
def neg_sharpe(weights, riskfree_rate, er, cov):
'\n Returns the negative of the sharpe ratio\n of the given portfolio\n '
r = portfolio_return(weights, er)
vol = portfolio_vol(weights, cov)
return ((- (r - riskfree_rate)) / vol)
|
def msd_risk(weights, target_risk, cov):
'\n Returns the Mean Squared Difference in risk contributions\n between weights and target_risk\n '
w_contribs = risk_contribution(weights, cov)
return ((w_contribs - target_risk) ** 2).sum()
| -1,417,795,964,434,329,000
|
Returns the Mean Squared Difference in risk contributions
between weights and target_risk
|
kit.py
|
msd_risk
|
jaimeaguilera/Investing-projects
|
python
|
def msd_risk(weights, target_risk, cov):
'\n Returns the Mean Squared Difference in risk contributions\n between weights and target_risk\n '
w_contribs = risk_contribution(weights, cov)
return ((w_contribs - target_risk) ** 2).sum()
|
def __init__(self, datasetPathList, nodeList, group, level='dataset', priority='normal', move='n', static='n', custodial='n', request_only='y', blocks=None, subscriptionId=(- 1), comments=''):
'\n Initialize PhEDEx subscription with default value\n '
if isinstance(datasetPathList, basestring):
datasetPathList = [datasetPathList]
if isinstance(nodeList, basestring):
nodeList = [nodeList]
self.datasetPaths = set(datasetPathList)
self.nodes = set(nodeList)
self.level = level.lower()
self.priority = priority.lower()
self.move = move.lower()
self.static = static.lower()
self.group = group
self.custodial = custodial.lower()
self.request_only = request_only.lower()
self.requesterID = None
self.status = 'New'
self.comments = comments
self.subscriptionIds = set([subscriptionId])
self.blocks = blocks
try:
for option in (self.static, self.custodial, self.request_only, self.move):
assert (option in ('y', 'n'))
assert (self.priority in PhEDEx_VALID_SUBSCRIPTION_PRIORITIES)
assert (self.level in ('dataset', 'block'))
if (self.level == 'block'):
assert (self.blocks is not None)
except AssertionError:
msg = 'The subscription is not a valid PhEDEx subscription.\n'
msg += 'Check the options for this subscription: \n'
msg += ('level: %s\n' % self.level)
msg += ('priority: %s\n' % self.priority)
msg += ('static: %s\n' % self.static)
msg += ('move: %s\n' % self.move)
msg += ('custodial: %s\n' % self.custodial)
msg += ('blocks: %s\n' % str(self.blocks))
raise PhEDExSubscriptionException(msg)
| -6,030,256,932,251,470,000
|
Initialize PhEDEx subscription with default value
|
src/python/WMCore/Services/PhEDEx/DataStructs/SubscriptionList.py
|
__init__
|
cbbrainerd/WMCore
|
python
|
def __init__(self, datasetPathList, nodeList, group, level='dataset', priority='normal', move='n', static='n', custodial='n', request_only='y', blocks=None, subscriptionId=(- 1), comments=):
'\n \n '
if isinstance(datasetPathList, basestring):
datasetPathList = [datasetPathList]
if isinstance(nodeList, basestring):
nodeList = [nodeList]
self.datasetPaths = set(datasetPathList)
self.nodes = set(nodeList)
self.level = level.lower()
self.priority = priority.lower()
self.move = move.lower()
self.static = static.lower()
self.group = group
self.custodial = custodial.lower()
self.request_only = request_only.lower()
self.requesterID = None
self.status = 'New'
self.comments = comments
self.subscriptionIds = set([subscriptionId])
self.blocks = blocks
try:
for option in (self.static, self.custodial, self.request_only, self.move):
assert (option in ('y', 'n'))
assert (self.priority in PhEDEx_VALID_SUBSCRIPTION_PRIORITIES)
assert (self.level in ('dataset', 'block'))
if (self.level == 'block'):
assert (self.blocks is not None)
except AssertionError:
msg = 'The subscription is not a valid PhEDEx subscription.\n'
msg += 'Check the options for this subscription: \n'
msg += ('level: %s\n' % self.level)
msg += ('priority: %s\n' % self.priority)
msg += ('static: %s\n' % self.static)
msg += ('move: %s\n' % self.move)
msg += ('custodial: %s\n' % self.custodial)
msg += ('blocks: %s\n' % str(self.blocks))
raise PhEDExSubscriptionException(msg)
|
def __str__(self):
'\n Write out useful information for this object\n :return:\n '
res = {'datasetPaths': self.datasetPaths, 'nodes': self.nodes, 'priority': self.priority, 'move': self.move, 'group': self.group, 'custodial': self.custodial, 'request_only': self.request_only, 'blocks': self.blocks}
return str(res)
| -1,481,429,788,718,934,000
|
Write out useful information for this object
:return:
|
src/python/WMCore/Services/PhEDEx/DataStructs/SubscriptionList.py
|
__str__
|
cbbrainerd/WMCore
|
python
|
def __str__(self):
'\n Write out useful information for this object\n :return:\n '
res = {'datasetPaths': self.datasetPaths, 'nodes': self.nodes, 'priority': self.priority, 'move': self.move, 'group': self.group, 'custodial': self.custodial, 'request_only': self.request_only, 'blocks': self.blocks}
return str(res)
|
def getDatasetsAndBlocks(self):
'\n _getDatasetsAndBlocks_\n\n Get the block structure\n with datasets and blocks\n '
return self.blocks
| 7,009,327,071,037,417,000
|
_getDatasetsAndBlocks_
Get the block structure
with datasets and blocks
|
src/python/WMCore/Services/PhEDEx/DataStructs/SubscriptionList.py
|
getDatasetsAndBlocks
|
cbbrainerd/WMCore
|
python
|
def getDatasetsAndBlocks(self):
'\n _getDatasetsAndBlocks_\n\n Get the block structure\n with datasets and blocks\n '
return self.blocks
|
def matchesExistingTransferRequest(self, phedexDataSvc):
'\n _matchesExistingTransferRequest_\n\n Check the given phedex data service to verify if an unapproved\n transfer request equal to this subscription is already in the system.\n '
if ((len(self.datasetPaths) != 1) or (len(self.nodes) != 1)):
msg = 'matchesExistingTransferRequest can only run in single node/dataset subscriptions'
raise PhEDExSubscriptionException(msg)
if (self.level != 'dataset'):
msg = 'matchesExistingTransferRequest is only supported by dataset subscriptions'
raise PhEDExSubscriptionException(msg)
node = next(iter(self.nodes))
dataset = next(iter(self.datasetPaths))
existingRequests = phedexDataSvc.getRequestList(dataset=dataset, node=node, decision='pending')['phedex']['request']
for request in existingRequests:
requestId = request['id']
requestInfo = phedexDataSvc.getTransferRequests(request=requestId)['phedex']['request']
if (not requestInfo):
logging.error("Transfer request %s doesn't exist in PhEDEx", requestId)
continue
requestInfo = requestInfo[0]
destinations = requestInfo['destinations']['node']
for nodeInfo in destinations:
if (nodeInfo['name'] == node):
break
else:
continue
phedexRequest = PhEDExSubscription(self.datasetPaths, self.nodes, self.group, self.level, requestInfo['priority'], requestInfo['move'], requestInfo['static'], requestInfo['custodial'], self.request_only)
if self.isEqualOptions(phedexRequest):
return True
return False
| 6,305,325,705,504,872,000
|
_matchesExistingTransferRequest_
Check the given phedex data service to verify if an unapproved
transfer request equal to this subscription is already in the system.
|
src/python/WMCore/Services/PhEDEx/DataStructs/SubscriptionList.py
|
matchesExistingTransferRequest
|
cbbrainerd/WMCore
|
python
|
def matchesExistingTransferRequest(self, phedexDataSvc):
'\n _matchesExistingTransferRequest_\n\n Check the given phedex data service to verify if an unapproved\n transfer request equal to this subscription is already in the system.\n '
if ((len(self.datasetPaths) != 1) or (len(self.nodes) != 1)):
msg = 'matchesExistingTransferRequest can only run in single node/dataset subscriptions'
raise PhEDExSubscriptionException(msg)
if (self.level != 'dataset'):
msg = 'matchesExistingTransferRequest is only supported by dataset subscriptions'
raise PhEDExSubscriptionException(msg)
node = next(iter(self.nodes))
dataset = next(iter(self.datasetPaths))
existingRequests = phedexDataSvc.getRequestList(dataset=dataset, node=node, decision='pending')['phedex']['request']
for request in existingRequests:
requestId = request['id']
requestInfo = phedexDataSvc.getTransferRequests(request=requestId)['phedex']['request']
if (not requestInfo):
logging.error("Transfer request %s doesn't exist in PhEDEx", requestId)
continue
requestInfo = requestInfo[0]
destinations = requestInfo['destinations']['node']
for nodeInfo in destinations:
if (nodeInfo['name'] == node):
break
else:
continue
phedexRequest = PhEDExSubscription(self.datasetPaths, self.nodes, self.group, self.level, requestInfo['priority'], requestInfo['move'], requestInfo['static'], requestInfo['custodial'], self.request_only)
if self.isEqualOptions(phedexRequest):
return True
return False
|
def matchesExistingSubscription(self, phedexDataSvc):
'\n _matchesExistingSubscription_\n\n Check the given phedex data service to verify if a PhEDEx subscription\n equal to this subscription is already in the system.\n '
if ((len(self.datasetPaths) != 1) or (len(self.nodes) != 1)):
msg = 'matchesExistingSubscription can only run in single node/dataset subscriptions'
raise PhEDExSubscriptionException(msg)
if (self.level != 'dataset'):
msg = 'matchesExistingSubscription is only supported by dataset subscriptions'
raise PhEDExSubscriptionException(msg)
node = next(iter(self.nodes))
dataset = next(iter(self.datasetPaths))
existingSubscription = phedexDataSvc.subscriptions(dataset=dataset, node=node)['phedex']['dataset']
if (len(existingSubscription) < 1):
return False
datasetInfo = existingSubscription[0]
for subscriptionInfo in datasetInfo['subscription']:
if (node != subscriptionInfo['node']):
continue
phedexSub = PhEDExSubscription(self.datasetPaths, self.nodes, self.group, subscriptionInfo['level'], subscriptionInfo['priority'], subscriptionInfo['move'], self.static, subscriptionInfo['custodial'], self.request_only)
if self.isEqualOptions(phedexSub):
return True
return False
| 1,436,007,145,053,543,200
|
_matchesExistingSubscription_
Check the given phedex data service to verify if a PhEDEx subscription
equal to this subscription is already in the system.
|
src/python/WMCore/Services/PhEDEx/DataStructs/SubscriptionList.py
|
matchesExistingSubscription
|
cbbrainerd/WMCore
|
python
|
def matchesExistingSubscription(self, phedexDataSvc):
'\n _matchesExistingSubscription_\n\n Check the given phedex data service to verify if a PhEDEx subscription\n equal to this subscription is already in the system.\n '
if ((len(self.datasetPaths) != 1) or (len(self.nodes) != 1)):
msg = 'matchesExistingSubscription can only run in single node/dataset subscriptions'
raise PhEDExSubscriptionException(msg)
if (self.level != 'dataset'):
msg = 'matchesExistingSubscription is only supported by dataset subscriptions'
raise PhEDExSubscriptionException(msg)
node = next(iter(self.nodes))
dataset = next(iter(self.datasetPaths))
existingSubscription = phedexDataSvc.subscriptions(dataset=dataset, node=node)['phedex']['dataset']
if (len(existingSubscription) < 1):
return False
datasetInfo = existingSubscription[0]
for subscriptionInfo in datasetInfo['subscription']:
if (node != subscriptionInfo['node']):
continue
phedexSub = PhEDExSubscription(self.datasetPaths, self.nodes, self.group, subscriptionInfo['level'], subscriptionInfo['priority'], subscriptionInfo['move'], self.static, subscriptionInfo['custodial'], self.request_only)
if self.isEqualOptions(phedexSub):
return True
return False
|
def addSubscription(self, subObj):
'\n _addSubscription_\n Add a new subscription to the subscription policy.\n If the same subscription key exist just add the node list\n '
for subscription in self._subList:
if subscription.isEqualOptions(subObj):
if subscription.isEqualNode(subObj):
subscription.addDatasetPaths(subObj)
return
self._subList.append(subObj)
return
| 5,781,099,127,773,631,000
|
_addSubscription_
Add a new subscription to the subscription policy.
If the same subscription key exist just add the node list
|
src/python/WMCore/Services/PhEDEx/DataStructs/SubscriptionList.py
|
addSubscription
|
cbbrainerd/WMCore
|
python
|
def addSubscription(self, subObj):
'\n _addSubscription_\n Add a new subscription to the subscription policy.\n If the same subscription key exist just add the node list\n '
for subscription in self._subList:
if subscription.isEqualOptions(subObj):
if subscription.isEqualNode(subObj):
subscription.addDatasetPaths(subObj)
return
self._subList.append(subObj)
return
|
def compact(self):
'\n _compact_\n\n Compact the subscription list by aggregating the subscriptions where the nodes\n share a list of dataset paths.\n '
bags = []
baggedIndexes = set()
for (i, subscriptionA) in enumerate(self._subList):
if (i in baggedIndexes):
continue
bags.append([subscriptionA])
for (j, subscriptionB) in enumerate(self._subList[(i + 1):], (i + 1)):
if (j in baggedIndexes):
continue
if (subscriptionA.isEqualOptions(subscriptionB) and subscriptionA.isEqualDatasetPaths(subscriptionB)):
bags[(- 1)].append(subscriptionB)
baggedIndexes.add(j)
newSubList = []
for bag in bags:
anchorSubscription = bag[0]
for subscription in bag[1:]:
anchorSubscription.addNodes(subscription)
newSubList.append(anchorSubscription)
self._subList = newSubList
| 2,831,347,083,717,089,300
|
_compact_
Compact the subscription list by aggregating the subscriptions where the nodes
share a list of dataset paths.
|
src/python/WMCore/Services/PhEDEx/DataStructs/SubscriptionList.py
|
compact
|
cbbrainerd/WMCore
|
python
|
def compact(self):
'\n _compact_\n\n Compact the subscription list by aggregating the subscriptions where the nodes\n share a list of dataset paths.\n '
bags = []
baggedIndexes = set()
for (i, subscriptionA) in enumerate(self._subList):
if (i in baggedIndexes):
continue
bags.append([subscriptionA])
for (j, subscriptionB) in enumerate(self._subList[(i + 1):], (i + 1)):
if (j in baggedIndexes):
continue
if (subscriptionA.isEqualOptions(subscriptionB) and subscriptionA.isEqualDatasetPaths(subscriptionB)):
bags[(- 1)].append(subscriptionB)
baggedIndexes.add(j)
newSubList = []
for bag in bags:
anchorSubscription = bag[0]
for subscription in bag[1:]:
anchorSubscription.addNodes(subscription)
newSubList.append(anchorSubscription)
self._subList = newSubList
|
def get_source(category):
'\n function that gets the json response to our url request\n '
get_source_url = NEWS_API_BASE_URL.format(category, api_key)
print(get_source_url)
with urllib.request.urlopen(get_source_url) as url:
get_source_data = url.read()
get_source_response = json.loads(get_source_data)
sources_result = None
if get_source_response['sources']:
sources_results_list = get_source_response['sources']
sources_result = process_sources(sources_results_list)
print(sources_result)
return sources_result
| 2,996,768,572,009,040,400
|
function that gets the json response to our url request
|
app/requests.py
|
get_source
|
ClarisseU/newsHighlight
|
python
|
def get_source(category):
'\n \n '
get_source_url = NEWS_API_BASE_URL.format(category, api_key)
print(get_source_url)
with urllib.request.urlopen(get_source_url) as url:
get_source_data = url.read()
get_source_response = json.loads(get_source_data)
sources_result = None
if get_source_response['sources']:
sources_results_list = get_source_response['sources']
sources_result = process_sources(sources_results_list)
print(sources_result)
return sources_result
|
def process_sources(sources_list):
'\n Function that checks the news results and turn them into objects\n \n Args:\n sources_list: A list of dictionaries that contain sources details\n '
sources_result = []
for source_item in sources_list:
author = source_item.get('author')
title = source_item.get('title')
imageurl = source_item.get('urltoimage')
description = source_item.get('description')
url = source_item.get('url')
id = source_item.get('id')
sources_object = Sources(author, title, imageurl, description, url, id)
sources_result.append(sources_object)
return sources_result
| 5,628,184,623,351,458,000
|
Function that checks the news results and turn them into objects
Args:
sources_list: A list of dictionaries that contain sources details
|
app/requests.py
|
process_sources
|
ClarisseU/newsHighlight
|
python
|
def process_sources(sources_list):
'\n Function that checks the news results and turn them into objects\n \n Args:\n sources_list: A list of dictionaries that contain sources details\n '
sources_result = []
for source_item in sources_list:
author = source_item.get('author')
title = source_item.get('title')
imageurl = source_item.get('urltoimage')
description = source_item.get('description')
url = source_item.get('url')
id = source_item.get('id')
sources_object = Sources(author, title, imageurl, description, url, id)
sources_result.append(sources_object)
return sources_result
|
def get_articles(id):
'\n Function that processes the articles and returns a list of articles objects\n '
get_articles_url = ARTICLE.format(id, api_key)
print(get_articles_url)
with urllib.request.urlopen(get_articles_url) as url:
article_data = url.read()
articles_response = json.loads(article_data)
articles_object = None
if articles_response['articles']:
response_list = articles_response['articles']
articles_object = process_articles(response_list)
return articles_object
| -5,579,780,585,189,511,000
|
Function that processes the articles and returns a list of articles objects
|
app/requests.py
|
get_articles
|
ClarisseU/newsHighlight
|
python
|
def get_articles(id):
'\n \n '
get_articles_url = ARTICLE.format(id, api_key)
print(get_articles_url)
with urllib.request.urlopen(get_articles_url) as url:
article_data = url.read()
articles_response = json.loads(article_data)
articles_object = None
if articles_response['articles']:
response_list = articles_response['articles']
articles_object = process_articles(response_list)
return articles_object
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.