semvec/pypi-packages huggingface dataset:
etpy 0.0.14
Reverse Engineering of My Etisalat App
Keywords: python,Reverse,Enginner,My Etisalat,Internet in egypt,egpt,etisalat,masr,etisalat masr

# Etpy | MyEtisalat Reverse Engineering
Etpy is a Reverse Engineering of MyEtisalat Masr android application
with this package you can control your etisalat number including cash wallet with python
```python
from etpy import Client
client = Client("011xxxxxxxx") # here you must put your etisalat phone number
client.send_verification_code() # We are using this function to send verification code to procced the login request
client.login_with_code(input("Code ?  : ")) # here you must enter the verification code recevied on your phone
print(client.getbalance()) # Printing User Balance
```
### Saving Session 
```python
print(client.access_token) # printing current user session
```
### Login with Saved Session
```python
client.session_login("xxxxxxxxxxxxxxxxxxxxxxxxxx....")
```
### Using Etisalat Cash Functions 
```python
client.cash_login("your cash wallet pincode") 
client.generate_online_shopping_card(1)  # Generating Online Card with x limit
client.cash_card_online_deposit(amount,"pan","expire-month","expire-year(2 digits only)","cvv") # Deposit Wallet With Credit Card (Still Developing)
client.cash_transfer("phone-number","amount-to-transfer") # transfer cash to any meeza wallet in egypt
client.wait_for_cash() # Wait for x amount and once amount is received the function will releasd
```

## Installing Etpy
```console
$ python -m pip install etpy
```
## Supported Features
- OTP Login
- Session Login 
- Getting User Balance
- Rechage User Balance ``using scrach card``
- Getting Daily Gifts
- Redeeming Daily Gifts
- Getting Call Log 
- Getting Calling Numbers
- Getting ``011`` Offers
- Redeeming ``011`` Offers
- Cash Features
 - Getting Balance
 - Money Transfer
 - Waiting For Cash Payment
 - Getting Transcation History
### To do list
- Getting User usage and subscriptions
- Out of credit Service
    - Sallefny 3la nota 
    - Megabytes 3al nota
- Cash
    - ~~Balance Rechrage~~ (done)
    - ~~Generating Online Payments Cards~~ (done)
    - ~~Cash Out~~ (done)
    - Purchase 
    - Bank to Wallet
django-database-backup-to-git 2.0
Django specific database backup system
Requires Python: >=3.6

# Django Database Backup to Git

A Django app, which makes a database backup in JSON format, commits and pushes it to a dedicated Git repository.
Intended to be run in deployment scripts and as a scheduled task.

## Installation and Setup

1. Install with pip:

```
pip install django-database-backup-to-git
```

1. Set up a Git repository outside of your application's main Git repository.
1. Add `dbbackup_git` to your `INSTALLED_APPS`.
1. In you settings file, specify the `DBBACKUP_GIT` setting

```py
DBBACKUP_GIT = {
    'DATABASE_BACKUP_FILENAME': os.path.join(BASE_DIR, '..', '..', 'myapp-db-backup', 'db.json'),
    'PUSH': True  # Determines whether the created backup is pushed to a remote repository, defaults to `True`
}
```

1. Run `manage.py help`, check that `dbbackup_git` is listed as available command.

## Usage

Typing `manage.py dbbackup_git` will also display output. When running it from *cron*, use `manage.py dbbackup_git --silent`.

## Running with *cron*

Create the following script `dbbackup-git.sh`:

```bash
#!/bin/bash

set -e

SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
cd $SCRIPT_DIR/../src

source ../venv/bin/activate

python manage.py dbbackup_git

```

Add it to hourly *cron*

```bash
sudo ln -s `pwd`/dbbackup-git.sh /etc/cron.hourly/dbbackup-git
```

Test it

```bash
run-parts --test /etc/cron.hourly
```

### *Cron* within a Docker container

If your project is living inside a Docker container the "Using Cron Within Your Containers" section of [this article](https://www.cloudsavvyit.com/9033/how-to-use-cron-with-your-docker-containers/) might be useful for you.
gitlab-todotxt 0.2.0
Synchronise your GitLab issues to a todo.txt file
Requires Python: >=3.0

# gitlab-todotxt

A tool to synchronize GitLab issues to a todo.txt file.

When started, gitlab-todotxt will read the configuration file, load all
issues, and write them into a todo.txt-type file of your choice.


## Configuration

gitlab-todotxt requires a configuration file. It expects the configuration
file by default in ~/.config/gitlab-todotxt/gitlab-todotxt.conf.

Each GitLab configuration is a separate section in the configuration file. The
title of that section must not contain any spaces.

This is an example configuration:

    [example.org]
    url = https://gitlab.example.org
    token = your-access-token
    projects = project1, project2
    unassigned = no


The minimal required options are:

 - `url`, the URL to the GitLab instance you are using.
 - `token`, your personal API access token.
 - `file`, the file where to write the tasks into.

Additional options are:

 - `namespaces`, the list of namespaces to consider when importing issues.
   Only namespaces on this list will be considered when imporrting issues.
   When left empty (the default), all accessible namespaces are considered.
 - `projects`, the list of projects to consider when importing issues. Only
   projects on this list will be considered when importing issues. When left
   empty (the default), all accessible projects are considered.
 - `users`, the list of users to consider when importing issues. Only issues
   that are assigned to a user of this list (or to yourself) are considered
   for importing. When empty (the default) no issues, unless assigned to you,
   are imported.
 - `labels`, the list of labels of which an issue must have at least one to
   be included in the import.
 - `unassigned`, whether or not unassigned issues should be imported.
 - `labels-are-projects`, whether or not labels of issues should be added as
   project tags.
 - `milestone-prefix`, the prefix you would like to have before the
   `milestone` element, if there is a milestone. Defaults to `milestone:`.
 - `format`, the format to write the todo.txt task in. See below for details.


### Format Option

The `format` option in the configuration can be used to customize in what
form your todo.txt tasks are written to file.

The default is

    {delegate} {title} {due} {project} {milestone} {estimate} {spent} {url}

These are also all possible fields:

 - `delegate`: if an issue is assigned to someone else than you, `@delegated`
   will be written in this place, followed by `to:` and the username of those
   the issue is assigned to
 - `title`: the title of the issue,
 - `due`: the due date of the issue or, if there is none, the due date of the
   milestone this task belongs to (if any); in form of a `due:` tag.
 - `project`: the project this task belongs to.
 - `spent`: the time spent on the task.
 - `estimate`: the estimated time for the task.
 - `milestone`: the milestone of the issue.
 - `url`: the URL to the actual issue at the GitLab website