semvec/pypi-packages huggingface dataset:
j-builds 0.0.2
Build and Deploy!

j builds
---------------------------

[![Python 3.7](https://img.shields.io/badge/python-3.7-blue.svg)](https://www.python.org/downloads/release/python-370/)

Build and Deploy!


Install
------------
```
pip3.7 install j_builds
pip3.7 install termcolor
```

Setup
------------
```
cat build.ini
```

```
[main]

[git]
# repo-directory = True to build it, False not to do so
repo-a = True
repo-b = True

[docker]
namespace = mynamespace

[before build]
cmd = echo "this runs before building"

[on success]
cmd = echo "this runs after a successful build"

[on fail]
cmd = echo "this runs after a not successful build"
```
contributics 1.0.1.dev1
Opensource Contribution Analytics

Stackalytics
============

Application Features
--------------------
Stackalytics is a service that automatically analyzes OpenStack
development activities and displays statistics on contribution. The features are:
 * Extraction of author information from git log, store it in the database;
 * Calculate metrics on number of lines changed (LOC) and commits;
 * Mapping authors to companies and launchpad ids;
 * Filter statistics by time, modules, companies, authors;
 * Extract blueprint and bug ids from commit messages;
 * Auto-update of database.

Quickstart
----------

To run Stackalytics, you first need to create two kind of configuration files.
The one is default_data.json which shows which sources(git repo, ml, etc.) need
to be analyzed. Another is stackalytics.conf which shows basic configuration like
HTTP listening host and port, etc. Stackalytics repository contains the default
files of these configuration under etc/ directory. It would be useful to copy and
change them as you like.

#. You need to install Stackalytics. This is done with pip after you check out
   Stackalytics repository::

    $ git clone https://git.openstack.org/openstack/stackalytics
    $ cd stackalytics
    $ sudo pip install -r requirements.txt
    $ sudo python setup.py install

#. Install and run memcached DB::

    $ sudo apt-get install memcached
    $ memcached -u memcache -d

#. Analyze data which are specifed on default_data.json and store the data into memcached DB::

    $ stackalytics-processor

#. Start HTTP server of Stackalytics::

    $ stackalytics-dashboard

#. Users can access Stackalytics site on http://127.0.0.1:8080 as the default.


Project Info
------------

 * Web-site: http://stackalytics.com/
 * Source Code: https://git.openstack.org/cgit/openstack/stackalytics
 * Wiki: https://wiki.openstack.org/wiki/Stackalytics
 * Launchpad: https://launchpad.net/stackalytics
 * Blueprints: https://blueprints.launchpad.net/stackalytics
 * Bugs: https://bugs.launchpad.net/stackalytics
 * Code Reviews: https://review.openstack.org/#/q/status:open+project:openstack/stackalytics,n,z
 * IRC: #openstack-stackalytics at freenode
grapi 0.1.4
Python 3 bindings for Graylog's REST API
Keywords: graylog,graylog-api,graylog api,python3 graylog,python3 graylog api,python3 graylog-api

# grapi
(Pronounced: gray-P-I)

Python3 bindings for Graylog's REST API

## Install
First, make sure you have at least Python 3.7 installed.
### Development
```
git clone git@github.com:interputed/grapi.git
cd grapi
pipenv install
```
### Library Usage
```
pip3 install grapi
```

## Example Usage
To use, you must first create an *access token* following the instructions at:
[Graylog REST API Documentation](http://docs.graylog.org/en/2.4/pages/configuration/rest_api.html#creating-and-using-access-token)
API does not support username/password logins as it makes it easier to accidentally expose user credentials.

Import after installation with pip:
```from grapi.grapi import Grapi```

Import access token string:
```token = "<your_access_token_string>"```

Set URL to desired API path:
```url = "https://<your Graylog URL>/api/search/universal/absolute"```

All currently implemented URL endpoints can be found in: ```grapi/endpoints.py```

The list of all possible endpoints that may be implemented in the future is found by adding ```/api/api-browser``` to the URL of your Graylog server.

Setup the Grapi object with url and token:
```my_api = Grapi(url, token)```

Build a dictionary of parameters mapped to string values for every parameter of your request:
```
my_params = {
  "query": "<your query string (lucene syntax)>", # Required
  "fields": "<fields you wish returned>", # Required
  "from": "<YYYY-MM-DD HH-MM-SS>", # Required
  "to": "<YYYY-MM-DD HH-MM-SS>", # Required
  "limit": 10 # Optional: Default limit is 150 in Graylog
}
```

Now, simply call the send method of my_api with the type of request method (get, post, put, delete):
```response = my_api.send("get", **my_params)```

That's it for a simple search in Python 3 using Graylog's REST API! Now you can manipulate the data however you wish directly in Python. To see the output of your search you can just print it as with anything else in Python:
```
print(response.json())
OR
print(response.text)
```

#### This is a work in progress, so if the method or endpoint you need isn't yet implemented, add it yourself and send a pull request, post to issues, or simply check back later and it should be added.