semvec/pypi-packages huggingface dataset:
repotofile-cli 0.2.2
A CLI tool to clone and process GitHub repositories.
Keywords: github cli tool repository conversion ai ai-tools

# repotofile-cli

`repotofile-cli` is a very light weight command-line tool that allows users to download a GitHub repository or an existing file directory and generate a text file containing the repository's code, excluding files specified in `.gitignore`. It's particularly useful for code analysis, backups and uploading to large language models like chatGPT.


## Features

- Clone any public GitHub repository.
- Optionally exclude configuration files, replacing their content with a placeholder.
- Generate a single text or markdown file with the entire codebase, neatly separated by files.
- Easy to install and use with a simple command.
- Ignore config files and directories by default
- Add custom files and directories to ignore

## Installation

To install `repotofile-cli`, ensure you have Python installed on your system, then run:

```bash
pip install repotofile-cli
```

## Usage

After installation, you can use the `repotofile` command or its shorthand `rtf`:

```bash
repotofile <repository-url> [options]
```

or

```bash
rtf <repository-url> [options]
```

or

```bash
repotofile <directory> [options]
```

### Options

- `-b`, `--branch` : Specify a branch or tag to download. Defaults to the default branch of the repository.
- `-o`, `--output` : Custom output file name or path. Defaults to '[repository-name].txt'.
- `--no-config` : Replace the content of configuration files with a placeholder comment.

### Examples

Cloning a repository and generating the default output file:

```bash
repotofile https://github.com/user/repo
```

Cloning a specific branch:

```bash
repotofile https://github.com/user/repo -b feature-branch
```

Generating a custom output file:

```bash
repotofile https://github.com/user/repo -o ~/Documents/repo_snapshot.txt
```

Ignoring custom files and directories:

```bash
    repotofile https://github.com/user/repo --ignore-files "*.log,*.txt" --ignore-dirs "build,docs"
```

## Contributing

Contributions to `repotofile-cli` are welcome! Please read our contributing guidelines (link to guidelines) to get started.

## License

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

## Contact

Maurits Bos - <maurits.bos@gmail.com>
Project Link: <https://github.com/mbbrainz/repotofile-cli>
nautiluscli 0.5.2
Command-line interface for NautilusDB
Requires Python: >=3.10,<4.0

# nautilusdb-cli

A command-line tool for [NautilusDB](http://nautilusdb.com), a fully-managed, 
cloud-native vector search service.

NautilusDB is currently in <ins>**public alpha**</ins>. We're actively improving 
the product and releasing new features and we'd love to hear your feedback! 
Please take a moment to fill out this [feedback form](https://forms.gle/pif6Vx2LqPjW5v4w5) to help us understand your use-case better.

> By default, all collections are subject to permanent deletion after 2 weeks. Please let us know if you need to keep it for longer via the feedback form.


## Quickstart
You can try out NautilusDB right away. We have prepared a special public 
collection ```openai-web``` that can answer questions about the contents of ```www.openai.com``` 

```shell
nautiluscli ask openai-web "what is red team?"
 ```
## Installation
Install a released NautilusDB cli from pip.

python3 version ```>= 3.10``` is required

```shell
pip3 install nautiluscli
```

## Examples:

### Create a new API key
You can create a new API key and set it in ```NAUTILUSDB_API_KEY``` 
environment variable. NautilusDB will use this key to authorize access to 
collections.
```shell
nautiluscli create-api-key
export NAUTILUSDB_API_KEY='<key>'
```

### Check the current CLI configuration
```shell
nautiluscli info
```

### Create a new Collection 
Create a new collection ```myCollection``` in the shared demo account. 
A collection will be created that is only accessible to the configured API key.
```shell
 nautiluscli create-collection myCollection
```

### List Collections
See the list of Collection accessible to you, including ```myCollection``` 
that you just created.
```shell
nautiluscli list-collections
```

### Upload file from URL
Index a PDF into ```myCollection```. In this example, we will index the original research paper on Transformers.
```shell
 nautiluscli upload-file myCollection https://arxiv.org/pdf/1706.03762.pdf
```

### Upload local file
Alternatively, upload a PDF from local file system for indexing.
```shell
nautiluscli upload-file myCollection README.md
```

### Ask questions 
You can now ask questions within the context of a collection and get answers. 
```shell
nautiluscli ask myCollection "what is a transformer?"
```

### Delete the Collection
You can optionally delete the collection. Deletions are non-reversible. 
```shell
nautiluscli delete-collection myCollection
```
rtde-ur 1.5.7
Forked from ur-rtde. A Python interface for controlling and receiving data from a UR robot using the Real-Time Data Exchange (RTDE) interface of the robot.

<div align="center">

A fork of the [ur-rtde](https://gitlab.com/sdurobotics/ur_rtde) library from sdu robotics.

Forked to add support for Python 3.11

</div>
bitopro 1.0.3
bitopro-api-python
Requires Python: >=3.7

# bitopro-api-python

SDK for the [BitoPro](https://www.bitopro.com/) API.

[Bitopro official API document](https://github.com/bitoex/bitopro-offical-api-docs)

### Installation

```bash
pip install bitopro-client
```

### Linux

```bash
cd ~/ && git clone https://github.com/bitoex/bitopro-api-python.git
cd ~/bitopro-api-python && cp bitopro/sample_test.py .

# update API key and secret
# vim sample_test.py

python3 sample_test.py
```

### Windows

```batch
cd %USERPROFILE%\Downloads
git clone https://github.com/bitoex/bitopro-api-python.git

cd bitopro-api-python
cd bitopro

# update API key and secret
# notepad sample_test.py

python3 sample_test.py
```
  
### Getting started

Create BitoPro client. Pass api keys only if
you are going to do authenticated calls. You can create an api key
[here](https://www.bitopro.com/api).

```python
bitopro_client = BitoproRestfulClient('apiKey', 'apiSecret')
```

### Limitations

#### Rate Limit

There is rate limits applied to each API, please check [API documentation](https://developer.bitopro.com/docs) for more detail.

#### Precisions

Both price and amount are subject to decimal restrictions, please check [official settings](https://www.bitopro.com/fees) for more detail.

#### Minimum order amount

Checkout the [official settings](https://www.bitopro.com/fees) of minimum amount.

### Public restful enpoint example

```python
from bitopro_restful_client import BitoproRestfulClient, CandlestickResolutin

if __name__ == '__main__':
    bitopro_client = BitoproRestfulClient('apiKey', 'apiSecret')

    '''
    Open restful test
    '''
    # [GET] list of currencies
    response = bitopro_client.get_currencies()
    print("List of currencies: ", response)

    # [GET] limitations and fees
    response = bitopro_client.get_limitations_and_fees()
    print("List of currencies: ", response)

    # [GET] order book
    pair = "BTC_USDT"
    response = bitopro_client.get_order_book(pair)
    print("Order book: ", response)

    # [GET] tickers
    response = bitopro_client.get_tickers(pair)
    print("Tickers: ", response)

    # [GET] trades
    response = bitopro_client.get_trades(pair)
    print("Trades: ", response)

    # [GET] candlestick
    response = bitopro_client.get_candlestick(pair, CandlestickResolutin._1d, 1650707415, 1678355415)
    print("Candlestick: ", response)

    # [GET] trading pairs
    response = bitopro_client.get_trading_pairs()
    print("Trading pairs: ", response)
```
persisty 0.0.17
A better persistence layer for python

# Persisty - a better persistence Layer for Python

The objective of this project is to provide a resource oriented approach
accommodating both security and caching rich enough to handle most use
cases while still being independant of the underlying persistence 
mechanism. 

Using [Servey](https://github.org/tofarr/servey) to provide access via 
REST and GraphQL in either a hosted environment or AWS lambda 
environemnt, the project includes out of the box support for both 
SQL (via SQLAlchemy) and Dynamodb.

## Concepts

### Stored Items

Stored items are marked by the [stored](persisty/stored.py) decorator.
This decorator is similar to dataclass, and allows specifying attributes,
keys, schemas, and indexes.

### Stores

A [Store](persisty/store/StoreABC.py) provides a unified interface for
interacting with stored items. [StoreMeta](persisty/store_meta.py) contains
info on what exactly a store supports

Standard Actions are:

* **create** an item
* **read** and item given its key
* **update** an item
* **delete** and item given its key
* **search** for items given filter and sort criteria
* **count** items given filter criteria
* **read_batch** read a batch of items given a list of keys
* **edit_batch** execute a batch of edits (create, update, delete operations)

### Keys

Each item within a store has a string key, derived from the item. (Possibly based on 
one or more of it's attributes) A [KeyConfig](persisty/key_config/key_config_abc.py)
controls this process

### Attributes

Stored items have [Attributes](persisty/attr/attr.py) associated with them, similar
to columns in a relational database. Attributes can have generators associated with
them.

## SearchFilters

Search operations can have [SearchFilters](persisty/search_filter/search_filter_abc.py) 
These can be natively supported (Converted to SQL or dynamodb query / scan criteria)
or run locally in python.

## Auto User Interfaces

Since this is built on top of OpenAPI, user interface options supplied by [Ewey](https://github.com/tofar/ewey)

## Examples

[The messenger Example App](examples/messenger_1) demonstrates a step by step build of an
application with security and business logic.


## Future Ideas

* REDIS Storage
* Elastic Search Storage
* Remote HTTP Storage
* A user app with support for OIDC, SAML and SCIM
* A Rate Limiting app / Rate Limit Access Control
* An Event Bridge Project (Backed by AWS Event bridge in AWS, or celery in other environments)

* A Distributed Lock
* An explicit custom index (Spatial RTree)
* A Z order index


## Installing local development dependencies

```
python setup.py install easy_install "persisty[all]"
```

## Release Procedure

![status](https://github.com/tofarr/persisty/actions/workflows/quality.yml/badge.svg?branch=main)

The typical process here is:
* Create a PR with changes. Merge these to main (The `Quality` workflows make sure that your PR
  meets the styling, linting, and code coverage standards).
* New releases created in github are automatically uploaded to pypi