semvec/pypi-packages huggingface dataset:
shadowray 0.1.6
A useful client of v2ray for linux
License: MIT
Requires Python: >=3
Keywords: pip,v2ray,shadowsocks,shadowray

# Shadowray
An useful client of v2ray for linux

## Simple usage
```bash
pip install shadowray
shadowray --autoconfig
shadowray --subscribe-add 'name,url'
shadowray --list
shadowray -s 1
```
for more detail about command:
```bash
shadowray --help
```
### Default config
#### Inbound:
+ protocol : socks5
+ port: 1082
+ auth: noauth
#### Outbound:
+ Traffic camouflage : tcp
## Usage
### Basic config
+ subscribe.json : the file used to save subscribes,you can specify it by using `shadowray --config-subscribe <path>`,but the file must be created by yourself
+ servers.json : the file used to save servers,you can specify it by using `shadowray --config-servers <path>`,but the file must be created by yourself
+ v2ray : you should specify the folder of v2ray-core,using `shadowray --config-v2ray <path>`

### For simplicity
Using `shadowray --autoconfig`,then it will complete the basic config automatically,include that downloading the lasted v2ray-core

### Subscribe
#### Add a subscribe
you can use `shadowray --subscribe-add '<name>,<url>'` to add a subscribe.
> Don't forget the `''`

#### Update subscribes
Using `shadowray --subscribe-update` to update all subscribes.Meanwhile,you can use `--port <number>` to specify a port of inbound.

### Proxy
#### List server
To see all available servers(proxies),using `shadowray [--list|-l]`.Then you will see some index,name of proxies,protocol of proxies,the index of proxies used to start a proxy

#### Start a proxy
For starting a proxy,you can use `shadowray [--start|-s] <index>`
> For running v2ray as a daemon,by using `--daemon` or `-d`
#### Stop daemon
Using  `shadowray --stop`
### Specify a config file of v2ray
You can use your config file via `[--config-self|-f] <path>`.For example,
`shadowray --config-self ~/config.json` or `shadowray -f ~/config.json`
### Export config
Using `shadowray --servers-export <index>:<path>` to export the specified config to file that specified by <path>
tei-reader 0.0.17
TEI Reader
License: MIT
Requires Python: >=3.5, <4

[![Build Status](https://travis-ci.org/UUDigitalHumanitieslab/tei_reader.svg?branch=master)](https://travis-ci.org/UUDigitalHumanitieslab/tei_reader)

# Python 3 Library for Reading the Text Content and Metadata of TEI P5 (Lite) Files

The library focuses on extracting the main text content from a file and provide the available metadata about the text.

# TL;DR

```bash
pip install tei-reader
```

```python
from tei_reader import TeiReader
reader = TeiReader()
corpora = reader.read_file('example-tei.xml') # or read_string
print(corpora.text)

# show element attributes before the actual element text
print(corpora.tostring(lambda x, text: str(list(a.key + '=' + a.text for a in x.attributes)) + text))
```

# More Explanation
A reader can be opened using `TeiReader()`. It is then possible to either call `read_file(file_name)` or `read_string(str)`. Both will return a `Corpora` object containing the following properties:

| Property | Description |
| --- | --- |
| `corpora[]` |  A corpora can contain sub-corpora. |
| `documents[]` | The `Document` objects directly part of this corpora. |

`Corpora` and `Document` all inherit from `Element`. In all objects deriving from this it is possible to call:

| Property | Description
| --- | --- |
| `attributes{}` | Contain attributes applicable to this element. If an attribute contains attributes these are also returned. (e.g. `encodingDesc::editorialDecl::normalization`) |
| `text` | Get the entire text content as `str` |
| `divisions[]` | Recursively get all the text divisions in document order. If an element contains parts or text without tag. Those will be returned in order and wrapped with a `PlaceholderDivision`. |
| `parts[]` | Recursively get the parts in document order constituting the entire text e.g. if something has emphasis, a footnote or is marked as foreign. Text without a container element will be returned in order and wrapped with a `PlaceholderPart`. |

`Attribute`, `PlaceholderDivision` and `PlaceholderPart` all support the same properties as `Element`.

# Upload to PyPi

```bash
python setup.py sdist
twine upload dist/*
```
xchange 0.0.6
Many cryptocurrency exchange APIs, a single and unified API client
License: MIT

# xchange
![Travis status](https://travis-ci.org/martinzugnoni/xchange.svg?branch=master)
![Coverage](https://codecov.io/gh/martinzugnoni/xchange/branch/master/graphs/badge.svg?branch=master)

Many cryptocurrency exchange APIs, a single and unified API client ��

## Installation

The project is hosted in PyPi, and you can install it using `pip` or `pip3`:

```
pip3 install xchange
```

## Example of usage

```python
>>> import os
>>> from xchange.factories import ExchangeClientFactory
>>> from xchange.constants import exchanges, currencies

# construct your API client
>>> ClientClass = ExchangeClientFactory.get_client(exchanges.KRAKEN)
>>> client = ClientClass(**{
...     "api_key": os.environ.get('KRAKEN_KEY'),
...     "api_secret": os.environ.get('KRAKEN_SECRET')
... })

# request API resources in an unified way
>>> ticker = client.get_ticker(currencies.BTC_USD)

>>> ticker
{'ask': Decimal('8590.00000'),
 'bid': Decimal('8589.90000'),
 'low': Decimal('8317.90000'),
 'high': Decimal('8610.00000'),
 'last': Decimal('8590.00000'),
 'volume': Decimal('1856.51064490')}

# API responses are wrapped into normalized models
>>> type(ticker)
<class 'xchange.models.kraken.KrakenTicker'>

# dynamic attribute assignation of response fields
>>> ticker.last
Decimal('8638.10000')
```

## Polymorphic requests

```python
>>> for exchange in exchanges.EXCHANGES:
...     client = ExchangeClientFactory.get_client(exchange)(**{
...         "api_key": "YOUR_KEY",
...         "api_secret": "YOUR_SECRET"
...     })
...     ticker = client.get_ticker(currencies.BTC_USD)
...     print("%s: $%d" % (exchange, ticker.last))
...

bitfinex: $8633
okex: $8749
kraken: $8633
```
tkate 0.7.1
A tkinter-based front-end GUI for trigger and monitoring hardware tests based on the ATE package
License: MIT
Requires Python: >=3.6.0

# Tk-Automated Test Environment (TkATE)

The [Automated Test Environment](https://github.com/slightlynybbled/ate) is a Python library
which provides useful structure for test creation and execution, but does not provide a user-defined
method of controlling that test environment.  The purpose of this project is to provide the
start button and to provide visual feedback as to the actual test that is executing.  The
implementation is done using a `tkinter.Frame` subclass which may be embedded into any tkinter-style
window.

# Installation

Installation is as easy as `pip install tkate`.

# Usage

You must set up your test so that it can successfully execute on the 
[ATE](https://github.com/slightlynybbled/ate).  Once it is set up there, then you are just a couple
of lines away from converting an ATE-based test to a TkATE.

We will start with the example application located within the ATE repository.  The high-level
functional bits are copied here for reference:

    # create the sequence of test objects
    sequence = [CommunicationTest(), PumpFlowTest()]
    ts = TestSequence(sequence=sequence, auto_run=False, loglevel=logging.DEBUG)

    # start the test as many times as you wish!
    for _ in range(3):
        ts.start()
        sleep(2.0)

Note that the test was simply started using the `TestSequence.start()` method.  Since we are
going to have a test frame that comes with TkATE, then we won't require the automated start and
can, instead, rely on the user button supplied.  Our complete sequence could be as simple as:

    # create the sequence of test objects
    sequence = [CommunicationTest(), PumpFlowTest()]
    ts = TestSequence(sequence=sequence, auto_run=False, loglevel=logging.DEBUG)

    window = tk.Tk()

    tkate_frame = TkAteFrame(window, ts)
    tkate_frame.grid()

    window.mainloop()

Note that most of the added code is related to simply creating the `window` object within
which the `TkAteFrame` is to be embedded.

There are two tests that are executed here, one `CommunicationTest` and one `PumpTest`.  Screenshots
of various possible scenarios are shown here:

## Communications Test Failure

![Communications Test Failure Screenshot](images/on-fail-comm.png)

## Flow Test Failure

![Flow Test Failure Screenshot](images/on-fail-flow.png)

## All Passing

![All Passing Screenshot](images/on-pass.png)
ogma 0.1.0
Ogma: A database access code generator for Java
License: MIT
Requires Python: >=3.6,<4.0

# Ogma

> According to legend, he is the inventor of Ogham, the runic language in which Irish Gaelic was first written. 

**Ogma** is a database access code generator for Java. It will take your database schema definition written in a Python-based DSL and generate (with jOOQ, among others) the necessary Java code to perform typed queries on that database.

It can also generate the necessary DDL to create the database structure according to spec.

*Ogma* has been written for MySQL and MariaDB, but could be made to work with other engines that are both supported by SQLAlchemy and jOOQ.

# How to install

Just run the usual for a Python package:

```bash
pip install ogma
```

Then you can run `ogma`.

# Code generation and other tools

*Ogma* obviously generates code, but it can also do other things. The tool is organized with subcommands.

## Generation

The `generate` subcommand is used to generate Java code from the model file. The model file is a Python with some restrictions and additions:

1. There is an implicit import of everything from `modelutils`
1. No imports are allowed

# For Developers
## Structure
 * `modelutils` contains all the code that is imported into the database model files and that internally deals with model operations.
 * `commands` contains the entry points for the tool's subcommands
 * `templates` contains *mustache* templates for jOOQ's configuration and additional generated Java code