semvec/pypi-packages huggingface dataset:
traitlets-paths 0.1.3
Traitlets module for pathlib.


# traitlets_paths

**Traitlets module for pathlib**

This package defines `traitlets` for all pathlib objects.

## Getting Started 

Install from pip:
```
pip install traitlets_paths
```

**Basic Example**

```python
from traitlets import HasTraits, default
from traitlets_paths import PurePath

class Foo(HasTraits):
    path = PurePath()

    @default('path')
    def _default_path(self):
        return 'path/to/foo'


foo = Foo()
foo.path
```
```
# On Posix systems
PurePosixPath('path/to/foo')

# or on Windows systems
PureWindowsPath('path/to/foo')
```

**How to get a TraitError**

When we try passing a bad type:
```
foo = Foo(path=5)
```
we get a TraitError:
```
TraitError: The 'path' trait of a Foo instance must be a pathlib.PurePath trait, but a value of 5 <class 'int'> was specified.
```

## Developing

Download and install this repo from source, and move into the base directory.
```
git clone https://github.com/Zsailer/traitlets_paths
cd traitlets_paths
```
If you use [pipenv](https://pipenv.readthedocs.io/en/latest/), you can install a developement version:
```
pipenv install --dev
``` 

Otherwise you can install a development version using pip
```
pip install -e .
```

## Licensing

The code in this project is licensed under MIT license.
repcomp 0.1
A package for comparing trained embedding models.

# repcomp

`repcomp` (short for representation comparison) is a package for comparing trained embedding models. You can use it to compare Deep Neural Networks, Matrix Factorization models, Graph Embeddings, Word Embeddings, etc.

`repcomp` supports the following embedding comparison approaches:

* Nearest Neighbors: Fetch the nearest neighbor set of each entity according to embedding distances, and compare model A's neighbor sets to model B's neighbor sets.
* Canonical Correlation: Treat embedding components as observations of random variables and compute the canonical correlations between model A and model B. 
* Unit Match: Form a unit-to-unit matching between model A's embedding components and model B's embedding components and measure the correlations of the matched units.

A simple example comparing random embeddings:

```python
  from repcomp.comparison import CCAComparison
  import numpy as np

  # Generate random embedding matrices
  num_samples = 100
  num_components = 10
  embedding_1 = np.random.random((num_samples, num_components))
  embedding_2 = embedding_1 + 0.5 * np.random.random((num_samples, num_components))

  # Run the comparison
  comparator = CCAComparison()
  sim = comparator.run_comparison(embedding_1, embedding_2)
  print("The canonical correlation similarity is {}".format(sim["similarity"]))
```

A more involved example comparing word embeddings:

```python
  import gensim.downloader as api
  import numpy as np
  from repcomp.comparison import NeighborsComparison

  # Load word vectors from gensim
  glove_wiki_50 = api.load("glove-wiki-gigaword-50")
  glove_twitter_50 = api.load("glove-twitter-50")

  # Build the embedding matrices over the shared vocabularies
  shared_vocab = set(glove_wiki_50.vocab.keys()).intersection(
    set(glove_twitter_50.vocab.keys()))
  glove_wiki_50_vectors = np.vstack([glove_wiki_50.get_vector(word) for word in shared_vocab])
  glove_twitter_50_vectors = np.vstack([glove_twitter_50.get_vector(word) for word in shared_vocab])

  # Run the comparison
  comparator = NeighborsComparison()
  print("The neighbors similarity between glove-wiki-gigaword-50 and glove-twitter-50 is {}".format(
    comparator.run_comparison(glove_wiki_50_vectors, glove_twitter_50_vectors)["similarity"]))
```
neutron-zvm-plugin 11.0.0
zVM ML2 mechanism driver and zVM neutron agent.

================================
openstack/networking-zvm Project
================================

About this project
------------------

This project provides the OpenStack Neutron mechanism driver and L2 agent for
the z/VM of IBM z Systems and IBM LinuxOne machines.

z/VM provides a highly secure and scalable enterprise cloud infrastructure
and an environment for efficiently running multiple diverse critical
applications on IBM z Systems and IBM LinuxONE with support for more virtual
servers than any other platform in a single footprint.
These z/VM virtual servers can run Linux, z/OS and more. 

For more information, please refer to http://www.vm.ibm.com/

Links
-----

* Documentation: `<http://networking-zvm.readthedocs.io/en/latest/>`_
* Source: `<http://git.openstack.org/cgit/openstack/networking-zvm>`_
* Github shadow: `<https://github.com/openstack/networking-zvm>`_
* Bugs: `<http://bugs.launchpad.net/networking-zvm>`_
* Gerrit: `<https://review.openstack.org/#/q/project:openstack/networking-zvm>`_
* License: Apache 2.0 license
rc-ssl-logtools 0.0.4
Tools to convert SSL logs to usable Python formats

# RoboCup Small Size League Python Log Tools

This package supports a minimal interface to parse and analyze log files generated by the RoboCup Small Size League.

## Installation
**rc-ssl-logtools** is on the PyPi package index. It can be installed by simply running the below command.
```
pip3 install rc-ssl-logtools
```
## Use
**rc-ssl-logtools** comes with a simple script to verify that the system is working. Download a log from http://wiki.robocup.org/Small_Size_League/Game_Logs, and run the below command. It will print all messages from time 0.0 seconds to 10.0 seconds.
```
ssldump -s 0.0 -d 10.0 <rc_ssl_logfile.gz>
```

**rc-ssl-logtools** allows python scripts to programmatically access these protobuf messages as well. This is how the `ssldump` script is implemented.
```python3
#!/usr/bin/env python3

import rc_ssl_logtools

frames = rc_ssl_logtools.log_frames(args.file, args.start_time, args.duration)

for f in frames:
    print(f)
```