semvec/pypi-packages huggingface dataset:
commentdater 0.1.0
Python command line tool to check for out of date comments.

commentdater
=======================

commentdater is a command line tool that reminds you to update your comments when you change a line of code.

Installation
-----------------------
`pip install commentdater`

Usage
-----------------------
    usage: commentdater [-h] -f FILE

    Check if your comments are out of date

    optional arguments:
      -h, --help            show this help message and exit
      -f FILE, --file FILE  file to check

Author
-----------------------
<lsingh@college.harvard.edu>
meta-info-tools 0.0.3
Tools to handle meta_info
Requires Python: >=3.6

# Meta Info Tools

Validates objects described with the MetaInfo format.
Meta info is a format initially developed in the [NOMAD Center of Excellence](https://nomad-coe.eu) to describe data.
See [NOMAD Archive](https://metainfo.nomad-coe.eu/nomadmetainfo_public/archive.html) and [https://kitabi.eu/nomad/metainfo/](https://kitabi.eu/nomad/metainfo/) for more information.
Meta info describes hierarchical data for both humans and computer.
The main aim is to have a flexible ad extensible definition.
[nomad-meta-info](https://github.com/fawzi/nomad-meta-info) contains the definition of the meta info used in NOMAD to describe atomistic simulations, in particular ab-initio simulations.

Install latest release:
```bash
pip install meta-info-tools
```

Run the command line utility
```bash
python -m meta_info_tools.meta_tool --help
```
(or python3 if your python still refers to python 2.x). It describes the various option of the meta tools.
It can be used to generates an exploded or reformatted version of a dictionary, check a dictionary, or generate documentation for it.
The cascade command does all those things if the files are put in a standard directory format (does the exploded dictionaries first, reformats them, then moves to the single dictionaries, regenerating them from the exploded version, reformatting them otherwise, finally performs checks and generates documentation for all available dictionaries.

## Development

files are formatted with [python black](https://pypi.org/project/black/)/
Install a local development version from this repository:
```bash
cd <repositoryDir>
pip install -e .
```
ConsoleMenu 1.0.1
Simplest console menu you've ever seen.

Made on dicts, it allows you to easily implement a console menu without a number of classes like 'MenuItem', etc.
Just setup a dict, type a title and that's all.
Home-page: https://github.com/EgorAlmikeev/ConsoleMenu
Author: Egor Almikeev
Author-email: ealmikeew@gmail.com
License: MIT
Download-URL: https://github.com/EgorAlmikeev/ConsoleMenu/archive/v_1.0.0.tar.gz
Description: UNKNOWN
Keywords: CONSOLE,MENU,CONSOLEMENU
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: Topic :: Software Development :: Build Tools
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
pylmeasure 0.2.0
A Python wrapper for L-Measure

[![Build Status](https://travis-ci.com/JustasB/pylmeasure.svg?branch=master)](https://travis-ci.com/JustasB/pylmeasure)
[![codecov](https://codecov.io/gh/JustasB/pylmeasure/branch/master/graph/badge.svg)](https://codecov.io/gh/JustasB/pylmeasure)
[![PyPI version](https://badge.fury.io/py/pylmeasure.svg)](https://badge.fury.io/py/pylmeasure)

# PyLMeasure: A Python Wrapper for LMeasure.

[PyLMeasure](https://pypi.org/project/pylmeasure/) is a Python wrapper library for the [command-line interface](http://cng.gmu.edu:8080/Lm/help/cmdLineUsageDoc.html) of the neuronal morphology analysis tool [L-Measure](http://cng.gmu.edu:8080/Lm/help/index.htm).

# Installation

To install the library, simply type in `pip install pylmeasure` in your terminal.

The above command includes the necessary binaries -- no need to download L-Measure separatelly or install Java.

# Usage

The basic usage is:

```
from pylmeasure import *

# Specify the L-Measure to compute, full list: http://cng.gmu.edu:8080/Lm/help/index.htm
LMOutput = getOneMeasure('Surface', 'path/to/cell.swc')

print("Surface area:",  LMOutput["TotalSum"])
```

For more examples, see [this Jupyter notebook](https://github.com/JustasB/pylmeasure/blob/master/PyLMeasure%20Usage.ipynb).

# Issues
If you encounter an issue, first make sure it's not due to L-Measure itself -- this library simply wraps the L-Measure executables. If it is, please contact the [L-Measure team](http://cng.gmu.edu:8080/Lm/). If the issue is with this library, please create an [issue on Github](https://github.com/JustasB/pylmeasure/issues).

# Contributing

To contribute, please [open an issue](https://github.com/JustasB/pylmeasure/issues) first and discuss your plan for contributing. Then fork this repository and commit [a pull-request](https://help.github.com/en/articles/about-pull-requests) with your changes.

# Acknowledgements

This wrapper library project was initialy started by [Ajayrama Kumaraswamy](https://github.com/ajkswamy). View [the original source](https://github.com/ajkswamy/python-Lmeasure).
C2D 0.0.2
optimal solution to read and save a config file.
Requires Python: >=3.6
Keywords: c2d,config,config-parser,config-reader

# C2D
optimal solution to read  and save a config file.

## Install
  ```
  pip install C2D
  ```
## Usage
1. Import C2D
  ```
  from C2D import C2D
  ```
2. Create object
  ```
  config=C2D.C2D()
  ```
3. Create config.ini
  ```
  from C2D import C2D

  key={'section': {'name': 'c2d',
                  'version': '1.0'
                  },
        'install': {'date': '23/12/2019'}
      }
# Create C2D Object      
config=C2D.C2D(keys=key)
#This will Save config.ini file
config.Save()
  ```

  if you want to give custom file NAME
  ```
  config=C2D.C2D(file='Test.ini',keys=key)
  ```

4. Read Config File
  ```
  from C2D import C2D
  config=C2D.C2D()
  keys_values=config.Read()
  print(keys_values)
  ```
  Output
    ```
    {'section': {'name': 'c2d', 'version': '1.0'}, 'install': {'date': '23/12/2019'}}
    ```

  To Read a Custom file
  ```
  config=C2D.C2D(file='Test.ini')
  ```

5. Read All Sections

  ```
  from C2D import C2D
  config=C2D.C2D()
  config.Read()
  print(config.Sections())
  ```
  Output
    ```
    ['section', 'install']
    ```

6. Read Values By Section Name
  ```
  from C2D import C2D
  config=C2D.C2D()
  config.Read()
  print(config.Values('install'))

  ```
  Output
    ```
    {'date': '23/12/2019'}
    ```
## Help
  ```
  >>> help(C2D)
Help on module C2D.C2D in C2D:

NAME
    C2D.C2D

CLASSES
    builtins.object
        C2D

    class C2D(builtins.object)
     |  C2D(file='config.ini', keys=None, sep='=')
     |  
     |  C2D is an class for creating and reading config.ini files.
     |  
     |  Create Object:
     |  -------------
     |      obj=C2D(file='config.ini',keys=None,sep='=')
     |  
     |      Parameter:
     |      ---------
     |          file: optional,any File name ,default file name is config.ini
     |          sep : optional,separator,defualt separator is =
     |          key : optional,an Dictionary object
     |  
     |          key={
     |                'section': {
     |                  'name': 'c2d',
     |                  'version': '1.0'
     |                },
     |                'install': {
     |                  'date': '23/12/2019'
     |                }
     |              }
     |  Methods:
     |  -------
     |      obj.Save()    : save config file
     |      obj.Read()    : read config file and return config dict object.
     |      obj.Sections(): list of section in config.ini
     |      obj.Values()  : all avialable paramters and Values
  ```
getserv 0.0.4
Retrieve a stable server to deploy
Requires Python: >=3.6

# getserv
![Build status](https://img.shields.io/github/workflow/status/davideperozzi/getserv/%5BDeploy%5D%20Build%20and%20deploy?style=flat-square)
[![License](https://flat.badgen.net/badge/license/MIT/blue)](./LICENSE)

This tool is used to retrieve stable servers from various services.

## Usage
The package is uploaded to [pypi.org](https://pypi.org/project/getserv/). In order to install the package you should use pip:
```
pip install getserv
```
> python >= 3.6 is required

## Basic usage
Basically the driver is responsible for delivering the ips to the main program. The main program will just scan all the ips received from the driver and checks whether a service on a given port is available:
```sh
getserv [...args] {driver_name} [...args]
```

### Changing the port to scan
The default port is `22`. You may change it with the `--test-port` (`-p`) option.

### Listing all IPs
The default beheavior is to only return one address. You can list all available server IPs by adding the `--list-all` (`-a`) option.

## The DigitalOcean driver
The digitalocean driver is used to filter droplets by multiple tags. Since the `doctl` can only filter by single tags, the driver will fallback to the REST API. It'll get information for the requested droplets and filters by the given tags. In order to get a running droplet from your droplet stack you execute this:

```sh
getserv digitalocean tag1,tag2
```

To authenticate yourself you can use either a cli argument or a environemt variable:

```sh
getserv digitalocean \
  --digitalocean-access-token XXXXXXXXXXX \
  tag1,tag2
```

Or to use the environment varible:
```sh
export DIGITALOCEAN_ACCESS_TOKEN=XXXXXXXX
getserv digitalocean tag1,tag2
```

> If everything is configured properly you should receive a single IP based on the availability of your droplets

## License
See the [LICENSE](./LICENSE) file for license rights and limitations (MIT).