semvec/pypi-packages huggingface dataset:
store-cli 1.0.0
A Tool to save commands used in terminal and create a backup on Google drive
License: MIT
Requires Python: >=3.6.0


![Store Logo](store.png)

A tool to store terminal commands and create a backup on Google drive.

## Features

* Save a command
* Search for a command
* Push store file ( Create backup on Google drive)
* Pull store file (Restore file from Google drive)
* List all commands

## Problem

After initially searching Google and Stackoverflow for a command, I have to search again the next time I need to use the command.
I think ctrl + r has a limit of commands it can save. 

## Installation

Python 3.6+

```commandline
$ pip install store-cli
```


## How to Use

```commandline
$ store --help
```
Displays the list of commands 

```commandline
$ store save --help
```
Displays the options available for a command

```commandline
$ store init
```
Initializes the file where the commands are saved.

```commandline
$ store save -d 'commit' -c 'git commit -m 'commit message'
```
Saves the command and the description of the command

```commandline
$ store search -q 'init'
```
Search for the query init

```commandline
store list
```
Lists all the commands that has been saved

```commandline
$ store push -f
```
This pushes the updated file to your Google drive account. Use the `--first` option the first time you are
using the `push` command. Subsequently, just use `store push` to push to Google drive.

```commandline
$ store pull -p 'push_id'
```
Whenever you use the push command, a push_id will be given to you. Save the id. You need this id to 
restore/sync your commands between computers. 

```commandline
$ store show
```
This displays the push id. You receive a push id after using the `push` command.


## Development Purposes

* For Development
    * clone the repo
    ```commandline
        $ git clone https://github.com/iyanuashiri/store.git
    ```
    * get your `client_secret.json` from [Oauth](https://console.cloud.google.com/apis/credentials/oauthclient). Make sure to enable [Drive Api](https://console.cloud.google.com/apis/library/drive.googleapis.com?q=Drive) for the project.
    * rename the client secret to `credentials.json` and place it in the same directory as setup.py.
    * install the package:
    ```sh
        # move into setup.py directory
        $ cd 
        # install package in edit mode
        $ pip install -e . #note the dot
    ```




## How to Contribute

Click here to read the [contributing](https://github.com/iyanuashiri/store/blob/master/CONTRIBUTING.md) guide.

Feature requests, suggestions and improvements are welcomed.


## Contributors

[Iyanu Ajao](http://github.com/iyanuashiri)
gitlab-jobs-exporter 0.2.0
prometheus exporter for exporting job metrics in a project
License: MIT

# GitLab CI Jobs Exporter
This tool allows for exporting build job metrics from GitLab CI.
It is used to monitor the experience as a user of the CI infrastructure.
More information at https://xinau.ch/notes/prometheus-gitlab-job-exporter/

## Installation
```
pip install gitlab_jobs_exporter
```
In the examples folder exists a sample systemd unit file template.

## Usage
Required environment variables are:
- `ACCESS_TOKEN` api token https://docs.gitlab.com/ce/user/profile/personal_access_tokens.html

Required arguments are:
- `--url` url of your gitlab instance (`https://gitlab.example.com`)
- `--project` project id of your jobs

Optional arguments are:
- `--interval` the scrape interval in seconds (default 10s)
- `--port` the port on which the server runs (default 9118)
gitlab-job-exporter 0.0.9
Package to scrape running_time, duration_time, status, etc. of Gitlab jobs using prometheus time series format
License: MIT

# Gitlab Job Exporter

Prometheus exporter providing some metrics concerning gitlab job runtime

## Installation

```
pip install gitlab_job_exporter
```
In the example folder exists a sample systemd unit file template.

## Usage

Configuration file

`/etc/prometheus/gitlab_job_exporter.json`

The exporter needs a configuration file in json format. The location of that file has to be passed via command line argument:

`./gitlab_job_exporter --config /etc/prometheus/gitlab_job_exporter.json`

Example configuration file:

```json
{
  "port":"9118",
  "interval":"10",
  "git_url":"<gitlab-url>",
  "git_project_id":"1234",
  "git_token":"XXXXXYYYYYYZZZZZZ",
  "git_branch":"gitlab_branch_example"
}
```
xypy 0.0.7
A simulation framework for supervised learning data. The functionalities are specifically                   designed to let the user a maximum degrees of freedom, to ultimately fulfill the research purpose.                   Furthermore, feature importances of the simulation can be created on a local and a global level.                    This is particular interesting, for instance, to benchmark feature selection algorithms.
License: MIT
Keywords: simulation machine learning supervised feature selection

Simulating Supervised Learning Data <img src="/img/Xy.png" alt="drawing" width="150px" align="right"/> 
===================================


With `xypy.Xy()` you can convienently simulate supervised learning data, e.g. regression and classification problems. 
The simulation can be very specific, since there are many degrees of freedom for the user. For instance, the functional 
shape of the nonlinearity is user-defined as well. Interactions can be formed and (co)variances altered. For a more 
specific motivation you can visit our [blog](https://www.statworx.com/de/blog/simulating-regression-data-with-xy-in-python/). 
I have adapted this package from my R version, which you can check out [here](https://www.github.com/andrebeleier/Xy).

### Usage

You can can checkout details about the package on [testPYPI](https://test.pypi.org/project/xypy/) or on 
[GitHub](https://www.github.com/andrebleier/xypy).

You can convienently install the package via PYPI with the following command.
```
pip install xypy
```
There is an example test script on my [GitHub](https://www.github.com/andrebleier/xypy), which will you get started
with the simulation.

### Simulate data 

You can simulate regression and classification data with interactions and a user-specified non-linearity. With 
the <code>stn</code> argument you can alter the signal to noise ratio of your simulation. I strongly encourage you to 
read this [blog post](https://www.statworx.com/de/blog/pushing-ordinary-least-squares-to-the-limit-with-xy/), 
where I've analyzed OLS coefficients with different signal to noise ratios.

```
# load the library
from xypy import Xy
# simulate regression data
my_sim = Xy(n = 1000, 
            numvars = [10,10], 
            catvars = [3, 2], 
            noisevars = 50, 
            stn = 100.0)

# get a glimpse of the simulation
my_sim

# plot the true underlying effects
my_sim.plot()

# extract the data
X, y = my_sim.data

# extract the true underlying model weights
my_sim.coef_
```

### Feature Selection

You can extract a feature importance of your simulation. For instance, to benchmark feature selection algorithms. 
You can read up on a small benchmark I did with this feature 
on our [blog](https://www.statworx.com/de/blog/benchmarking-feature-selection-algorithms-with-xy/). 
You can perform the same analysis easily in Python as well.

```
# Feature Importance 
my_sim.varimp()
```
<img src="/img/imp.png" alt="drawing"/> 

Feel free to [contact](mailto:andre.bleier@live.de) me with input and ideas.