semvec/pypi-packages huggingface dataset:
platform-migrator 1.1.0
Migrate software from one system to another
License: MIT

=================
Platform Migrator
=================

Platform Migrator is an application to migrate software from its current
system to a different system. System here is defined by the package managers
that will be used to install any required packages.

Installation
------------

To run Platform Migrator, you will need Python 2.7 or greater on the base
system, i.e. the system which currently has the software, and Python 3.5 or
greater on the target system, i.e. the system to which the software has to be
migrated. Currently, only Linux based operating systems are supported. It may
work on other OSes but has not been tested.

Platform migrator should be installed on the target system only. It will copy
the necessary files over to the base system as required.

Platform Migrator can be installed from PyPI with ::

    pip3 install --user platform-migrator

or from this git repo with ::

    git clone https://gitlab.com/mmc691/platform-migrator
    cd platform-migrator
    python3 setup.py install --user

Execution
---------

The application is executed in 4 steps:

1. Configure the application as per the docs.
2. Start the server on the target system with ``platform-migrator server start``.
   See the docs for complete set of options available.
3. On the base system, execute the following on the command line: ::

   curl http://<server-name>:<server-port>/migrate > script.py
   python script.py

4. Back on the target system, run ``platform-migrator migrate <name> <config>``.
   The docs have the full set of options for this as well.

If the migration was successful, the software will be saved in the configured
output directory.

Documentation
-------------

Documentation for the project is available at
https://platform-migrator.readthedocs.io/ and also in the
`docs/ <https://gitlab.com/mmc691/platform-migrator/tree/master/docs>`_
directory of this repository.

Acknowledgements
----------------

This application was written with the support and guidance of
`Prof. Dennis Shasha <https://cs.nyu.edu/cs/faculty/shasha/>`_ and
`Prof. Cristophe Pradal <https://team.inria.fr/virtualplants/christophe-pradal/>`_
as part of a capstone project at New York University.
fscast 0.0.3a1
FIle System Templates
License: MIT
Requires Python: >=3.6

Cast
====

    command line app for file system templates.

Cast can modify the structure of multiple directories at once. Provided
these directories are registered for a common template - moving,
renaming or deleting folders from that template will apply those changes
to the directories (called instances of the template).

Installation
------------

Linux:

.. code:: sh

    git clone https://github.com/taesko/cast.git
    cd cast
    pip install .

NOTE: This project has only been tested on linux. Installation is no
different on other OS provided git and pip are installed, but it's not
guaranteed to work properly.

Usage example
-------------

Use any existing directory to make a template out of it.

.. code:: sh

    cast add template_name ./dir_path

Register any other directory to that template as it's instance

.. code:: sh

    cast register template_name /directory/we/want/registered

If the directory's structure is not conformed to the template's an error
is raised. That is the instance must contain directories with the same
as the template's. (it is OK for the instance to have other directories
as well)

Create additional directories inside a template:

.. code:: sh

    cast add -m template_name various dir_names dir_names/similar to mkdir arguments

Rename a directory inside a template

.. code:: sh

    cast mv template_name relative_src_path relative_dst_path

Remove a directory from a template

.. code:: sh

    cast rm template_name multiple relative/directory/paths

Commands that modify a templates structure all take the name of the
template as a first argument and relative paths (considered from the
root of the template not the current working directory) to the desired
directories as additional arguments. Moving and renaming directories by
default applies the same changes to instances of the template as well
but this is not true for removing directories.

For full information:

.. code:: sh

    cast --help

Development setup
-----------------

There is no development branch (yet) and setup is nearly identical to
user installation.

.. code:: sh

    git clone https://github.com/taesko/cast.git
    cd cast
    pip install -e .

Release History
---------------

-  0.0.2

   -  Add proper logging (log file can be found in ~/.cast/logs.txt).

-  0.0.1

   -  Work in progress

Meta
----

Author: Antonio Todorov – taeskow@gmail.com

Distributed under the MIT license. See ``LICENSE`` for more information.

Contributing
------------

Fork and submit a pull request.
atum 0.3.0-1
Erlang-like atoms in Python 3
License: MIT

atum
====

Atum is a tiny Python library that you can use to emulate the basic
functionality of Erlang’s ``atom`` in your Python scripts.

**Status: Beta; this is an experiment.**

Erlang documentation:
~~~~~~~~~~~~~~~~~~~~~

   .. rubric:: 3.3 Atom
      :name: atom

   An atom is a literal, a constant with name. An atom is to be enclosed
   in single quotes (’) if it does not begin with a lower-case letter or
   if it contains other characters than alphanumeric characters,
   underscore (_), or @. Examples:

   ::

      hello
      phone_number
      'Monday'
      'phone number'

   http://erlang.org/doc/reference_manual/data_types.html

Unlike Erlang’s atom, ``atum`` does not impose the same limitations. You
may import any valid Python name from atum - even all uppercase.

Install
-------

::

   $ pip install atum

Examples
--------

Instead of writing:

.. code:: python

   @app.route('/register', methods=['GET', 'POST'])
   def register():
       pass

You could write:

.. code:: python

   from atum import GET, POST

   @app.route('/register', methods=[GET, POST])
   def register():
       pass

This might be useful if you use autocompletion. Another benefit is
exceptions occur sooner in case of typos, since the interpreter itself
validates the imported names. Pay attention when importing, simply
tab-to-complete later.

You can compare an atum with another atum or a string.

.. code:: python

   from atum import machine, human

   assert human == human
   assert machine == machine
   assert machine == 'machine'
   assert human != machine 
   assert human is human
   assert machine is machine

Atums also make for readable sentinel values or event-names.

.. code:: python

   from atum import user_is_awake
   from queue import Queue

   q = Queue()

   q.put(user_is_awake)

   assert q.get() == user_is_awake

Technical Details
~~~~~~~~~~~~~~~~~

Atum simply imports Python strings with the same content as their name.

Here is the content of atum.py in its entirety:

.. code:: python

   import sys as _sys

   # intern() is a builtin in Python 2.
   if _sys.version_info > (3, 0):
       intern = _sys.intern


   class Atum(object):
       def __getattr__(self, item):
           if item.startswith('__'):
               return self.__getattribute__(item)
           return intern(item)

       def __getitem__(self, item):
           return item


   _sys.modules[__name__] = Atum()

Known Issues
~~~~~~~~~~~~

-  Atum does not support using ``@`` in imported names as Python’s
   syntax does not allow it.
ntab 0.3.2
Simple numerical tables
License: MIT
Keywords: data


A lightweight Python tabular data structure.

Collects parallel numpy arrays into a tabular data structure.  Provides
syntactic sugar for column- and row-wise access, and basic grouping and
aggregation.  Avoids copies and type conversions; does not mess around with the
underlying numpy arrays.  Much less functionality than Pandas, with many fewer
lines of code.