Saravanan666/pypi-org huggingface dataset:
Package: backupdb
backupdbAn open-source CLI tool for backing up PostgreSQL database Locally or to Amazon S3 bucketUsageYou will pass in the following on the command line:The CLI commandbackupThedatabase URLyou need to connect toThestorage driver (S3 or Local)Thedestination (S3 bucket or local path)Installation$pipinstallbackupdbSyntax$backupdbpostgres://[USERNAME]:[PASSWORD]@[SERVER_IP:80/<db_name>--driver<driver_type><destination>Example usage for S3 backup$backupdbpostgres://[USERNAME]:[PASSWORD]@[SERVER_IP:80/<db_name>--drivers3mybucket01Example usage for Local backup$backupdbpostgres://[USERNAME]:[PASSWORD]@[SERVER_IP:80/<db_name>--driverlocal/var/local/mybackup.sqlInstallation From SourceTo install the package after you've cloned the repository, you'll
want to run the following command from within the project directory:$ pip install --user -e .Preparing for DevelopmentFollow these steps to start developing with this project:Ensurepipandpipenvare installedClone repository:git clone git@github.com:sharhan-alhassan/backupdbcdinto the repositoryActivate virtualenvsource /venv/bin/activateInstall dependencies:pip install -e .orpip install -r requirements
Package: backup-devops
Azure devops backupA tool to make a backup of an azure devops organizationInstallationpip install backup-devopsRun the backup processConfigure the environment variables to specify the azure devops organization to backup:AZDEVOPS_BACKUP_TARGET_ORGAAZDEVOPS_BACKUP_PAT_TARGET_ORGAConfigure the environment variables for where to host the backup (a target azure devops organization):AZDEVOPS_BACKUP_TARGET_ORGAAZDEVOPS_BACKUP_PAT_TARGET_ORGApython -m backup_devopsWhat is backed upsource code following the original hierarchy (project, repository)work items and comments
Package: backupdir
backupdirBackupDir (backup directory).
The program copies the source directory (with all subdirectories) to the specified location and zips it.Setuphttps://pypi.org/project/backupdir/pip install backupdirExample1:import backupdir

# ARCHIVE LOCAL
SOURCE_DIR = '' # use current dir when SOURCE_DIR = ''
TARGET_DIR = "D:\\TEMP\\backup"

backupdir.archive_local(SOURCE_DIR, TARGET_DIR)Documentationhttps://best-itpro.ru/news/backupdir/
Package: backup-folder-to-zip
Backup folder to zipCopies an entire folder and its contains into a zip file whose filename increments.Install$pipinstallbackup-folder-to-zipHow to use# Import pakagefrombackup_folder_to_zipimportbackup#  Save local foldersfrom_folder="c:\\user\\my_files"to_folder="c:\\user\\backup_of_my_files"# backup foldermybackup=extractor.Extractor(from_folder,to_folder)
Package: backup-github-org
GitHub-BackupProject descriptionApplication for backing up information about a GitHub organizationInstallationYou can clone this repository and set up the environment directly from the command line using the following command:gitclonegit@github.com:cloud-labs-infra/github-backup.gitcdgithub-backup
poetryinstallTestingYou can run the tests using the following command:poetryrunpytest--cov=./--cov-report=xmlThis command runs all unit tests and calculates coverageUsageCLI Usage is as follows:poetry run backup-github [-h] [-t TOKEN] [-o OUTPUT_DIR] [-r REPOSITORY [REPOSITORY ...]] [-i] [-p] [-m]
                                           [--all]
                                           ORGANIZATION_NAME

Backup a GitHub organization

positional arguments:
  ORGANIZATION_NAME                     github organization name

options:
  -h, --help                            show this help message and exit
  -t TOKEN, --token TOKEN
                                        personal token
  -o OUTPUT_DIR, --output-directory OUTPUT_DIR
                                        directory for backup
  -r REPOSITORY [REPOSITORY ...], --repository REPOSITORY [REPOSITORY ...]
                                        name of repositories to limit backup
  -i, --issues                          run backup of issues
  -p, --pulls                           run backup of pulls
  -m, --members                         run backup of members
  --all                                 run backup of all dataBackup structure.
└── organization
    ├── members
    │ └── login1
    │     ├── member.json
    │     └── membership.json
    └── repos
        └── repo1
            ├── content
            │ └── repo1.git
            ├── issues
            │ └── 1
            │     ├── assignee.json
            │     ├── comments
            │     ├── issue.json
            │     └── user.json
            ├── pulls
            │ └── 2
            │     ├── assignee.json
            │     ├── base.json
            │     ├── comments
            │     │ └── 1
            │     │     ├── comment.json
            │     │     └── user.json
            │     ├── head.json
            │     ├── pull.json
            │     ├── reviews
            │     │ ├── 1
            │     │ │   ├── review.json
            │     │ │   └── user.json
            │     │ └── 2
            │     │     ├── comments
            │     │     │ └── 1
            │     │     │     ├── comment.json
            │     │     │     └── user.json
            │     │     ├── review.json
            │     │     └── user.json
            │     └── user.json
            └── repo.jsonProject statusThe project is currently in a development state
Package: backup-juggler
Backup Juggler: Multiple copies of files and directories simultaneously made easyBackup Juggler is a command-line tool that allows you to perform multiple copies of files and directories simultaneously. The whole application is based on a command calledbj. This command has a subcommand related to each action that the application can perform. Likedo-backupsandget-size.InstallationTo install the Backup Juggler CLI, we recommend that you usepipx, although this is just a recommendation! You can also install the project with the manager of your choice. For full installation instructions see theinstallation documentationDocumentationThe goal of this project is to help users who need to make multiple copies of files and directories simultaneously. See thequick start guideor for full instructions of the current version of Backup Juggler see thetutorial documentation.ContributeThe fullcontributing documentationprovides useful guidance, but if you have any questions or need help during the contribution process, feel free to open anissue on the project's GitHub repositoryand ask for help. We're happy to assist you.ResourcesReleasesDocumentationIssue Tracker
Package: backupman
Incremental Backup using RSYNC+SSHInstallationInstall fromPyPisudo -H pip install backupmanInstallDevelopment versionsudo -H pip -i git+https://github.com/grepos/python-backupman.gitUsagesNAME
       backupman - backup script using rsync

NAME

SYNOPSIS
       backupman [-i] [-d DAYS] [-e rsh options] <SRC-URI> <BKUP-DST> 


DESCRIPTIONS


Mandatory arguments to long options are mandatory for short options too.
       -d,  --delete-old-backup=DAYS
                            delete old backup whitch backups older than DAYS ago.
       -e,  --rsh=RSH-OPTIONS    specify the remote shell to use
       -i,  --incremental        incremental backup
       -r,  --run-as-root        remote rsync command run as root using sudo command
            --help               display this message and exit
            --version            output version information and exit

  SRC-URI: Backup source represented by uri scheme.

  PROTOCOL://[USERNAME[:PASSWORD]@]HOSTNAME[:PORT]/PATH/TO/BACKUP

  Connect to backup source using SSH
    ssh://examples.com/some/directory
    ssh://examples.com:2222/some/directory
    ssh://username@examples.com/home/directory
    ssh://username:password@examples.com/home/directory

  Backup source located in local filesystem
    fs://some/directory
    fs:///some/directory


AUTHOR
       Written by E.K. KIM (euikook@{gmail.com, grepos.com}) 

COPYLIGHT
       The MIT Lisense

       Copyright (c) 2018 E.K. KIM (euikook@gmail.com)

       Permission is hereby granted, free of charge, to any person obtaining 
       a copy of this software and associated documentation files 
       (the "Software"), to deal in the Software without restriction, 
       including without limitation the rights to use, copy, modify, merge, 
       publish, distribute, sublicense, and/or sell copies of the Software, and
       to permit persons to whom the Software is furnished to do so, subject to 
       the following conditions:

       The above copyright notice and this permission notice shall be included 
       in all copies or substantial portions of the Software.

       THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
       EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 
       OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
       IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
       DAMAGES OR OTHER LIABILITY,
       WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
       FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
       OTHER DEALINGS IN THE SOFTWARE.

SEE ALSO
       please see https://blog.grepos.com/2018/02/20/incremental-backup-using-rsyncssh/Define exclude filesA .backupman.excludes file specifies intentionally unsync files that Rsync should ignore.
Files already synced by Rsync are deleted; see the NOTES below for details..backupman.excludes file MUST BE located at TOP OF BACKUP SOURCE.backupman sync .backupman.excludes first than sycn other.Examples/mnt
/proc
/tmp
/sys
/dev
/run
/sys/fs/cgroup
Package: backupmanager
This is a tool to control various backup programs (at least that’s the idea, only borg is supported at the moment)
Backupmanager uses the config file/etc/backup.yml(by default) to read what to backup and where to and it will pass
the correct arguments to the selected backup tool.InstallationInstall backupmanager withpip3 install backupmanager. Now you can usebackupmanager initto create a template config
file in/etc/backup.yml
Package: backup_monkey
A monkey that makes sure you have a backup of your EBS volumes in case something goes wrong.It is designed specifically for Amazon Web Services (AWS), and uses Python and Boto.This script is designed to be run on a schedule, probably by CRON.Usageusage: backup-monkey [-h] [--region REGION]
                     [--max-snapshots-per-volume SNAPSHOTS] [--snapshot-only]
                     [--remove-only] [--verbose] [--version]

Loops through all EBS volumes, and snapshots them, then loops through all
snapshots, and removes the oldest ones.

optional arguments:
  -h, --help            show this help message and exit
  --region REGION       the region to loop through and snapshot (default is
                        current region of EC2 instance this is running on).
                        E.g. us-east-1
  --max-snapshots-per-volume SNAPSHOTS
                        the maximum number of snapshots to keep per EBS
                        volume. The oldest snapshots will be deleted.
                        Default: 3
  --snapshot-only       Only snapshot EBS volumes, do not remove old snapshots
  --remove-only         Only remove old snapshots, do not create new snapshots
  --verbose, -v         enable verbose output (-vvv for more)
  --version             display version number and exitExamplesCreate snapshots of all EBS volumes in us-east-1:backup-monkey --region us-east-1Delete snapshots of EBS volumes in us-west-1 where a volume has more than 5 snapshots:backup-monkey --region us-west-1 --max-snapshots-per-volume 5 --remove-onlyInstallationYou can install Backup Monkey using the usual PyPI channels. Example:sudo pip install backup_monkeyYou can find the package details here:https://pypi.python.org/pypi/backup_monkeyAlternatively, if you prefer to install from source:git clone git@github.com:Answers4AWS/backup-monkey.git
cd backup-monkey
python setup.py installWarningMake no mistake. This script WILL delete snapshots. This script WILL create
snapshots, which can cost you money. There really are no warranties or
guarantees. For costs, refer tohttp://aws.amazon.com/ec2/pricing/Source CodeThe Python source code for Backup Monkey is available on GitHub:https://github.com/Answers4AWS/backup-monkeyAbout Answers for AWSThis code was written byPeter
Sankauskas, founder ofAnswers for
AWS- a company focused on helping businesses
learn how to use AWS, without doing it the hard way. If you are looking for help
with AWS, pleasecontact us.LicenseCopyright 2013 Answers for AWS LLCLicensed under the Apache License, Version 2.0 (the “License”); you may
not use this file except in compliance with the License. You may obtain
a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable
law or agreed to in writing, software distributed under the License is
distributed on an “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied. See the License for the specific
language governing permissions and limitations under the License.
Package: backupmysystemusb2usb
backupmystemusb2usb is a Creative Commons Python package to copy usb key.Its runs on Python 3.7 and has a dependency for yaml, and another one for the gui.Installation without the sourceTo installbackupmysytemusb2usbpackage run the following command:sudoapt-getinstalllibyaml-devpython3-gisudo-Hpip3installbackupmystemusb2usbYou have to create a config.yml file (you can save it into your ~/.local/share/backupmysystemusb2usb directory)UUID_1_Master:790d1fbb-96ed-46c3-868d-08e05e223fa7UUID_1_Slave:790d1fbb-96ed-46c3-868d-08e05e223fa7Temp_img:/home/stephane/Temp/Linux.imgTemp_log:/home/stephane/Temp/BackupMySystem-Temp.logKill_dd:TrueUUID listsudoblkidFind your device and to change the label if the device master UUID is the same as the slave UUID (for exemple: if you cancel in copying temporary img to disk slave), you have to put a date upper on master than slaveWarningUUID is not Label !sudoe2label/dev/sd_1"19991231235959"For the deamon, write arun.pyfor running by user root with chmod 700#!/usr/bin/env python3importsysimportyamlfrombackupmysystemusb2usb.usb2usbimportusb2usbtry:u2u=usb2usb(sys.argv[1])u2u.backup()exceptyaml.YAMLError:exit()You can create a service systemd if you planed to backup your usb key every day in the morning. You can wakeonlan from a raspberrypi or with another technicwakeonlanMACADRESScrontab-e# write your cronsudoservicecronreloadNow to create a daemon in startup (without console).Use this name “backupmysystemusb2usb” because in source const.py this file is a constant for GUI progress for non-root usercd/etc/systemd/systemvibackupmysystemusb2usb.serviceWrite[Unit]After=ssh.service[Service]WorkingDirectory=/your/working/path/ExecStart=/usr/bin/sh-c"/your/working/path/run.py /your/working/path/config.yml"[Install]WantedBy=default.targetEnable and startsudosystemctldaemon-reloadsudosystemctlenablebackupmysystemusb2usbThen the service start on reboot.
If you will test now the service :sudosystemctlstartbackupmysystemusb2usbCheck the log (the last 20 messages)sudojournalctl--unitbackupmysystemusb2usb-n20You can go to check your output log file configured by config.ymlNow we have to create the shell return for non-root user gui.pytouchgui.pychmod700gui.pyvigui.pyAnd write in file#!/usr/bin/env python3importyamlfrombackupmysystemusb2usb.usb2usbimportusb2usbu2u=usb2usb('/path/to/your/config.yml')u2u.gui()You can create a autostart Gnome desktop startupcd~/.config/autostarttouchbackupmysystemusb2usb.desktopchmod744vibackupmysystemusb2usb.desktopAnd in your editor enter[DesktopEntry]Name=BackupmysystemusbtousbComment=CopydiskwiththesamespaceExec=/your/working/path/gui.pyIcon=org.gnome.TerminalPath=/your/working/path/Terminal=trueHidden=falseType=ApplicationCategories=Utility;Application;Installation from sourceTo install the latest developement version run the following command:gitclonehttps://github.com/stephaneworkspace/backupmysystemusb2usbVersions1.04Change license to Creative Commons1.03Change license to Creative Commons1.02Fix bug and rename label usb key1.0.1Add gui Gtk0.0.16Alpha version
Package: backupp
backuppBack ups your folder to your preferred local or network destination reading or creating a gitignore file.installation-U for the latestpip install backupp -U         # or 
# pip3 install backupp -UUsage from console (Win) / terminal on (linux / Mac)$ backupp /some_folder/that_folder  my_backup_folder

$ backupp /some_folder/that_folder  path/to_my_backup_folder

# backup current folder
$ backupp .  path/to_my_backup_folder 

# backup parent folder
$ backupp ..  path/to_my_backup_foldergitignore filebackupp package looks for a .gitignore file. If it does not exist it creates one for your folder. You may modify it to create rules which files/ folders to ignore just like git does.setup global backup folderbackupp --setup my_favorite_backup_folder

backupp some_foldercheck backup setupdisplays your current setup and preferencesbackupp --checkbackup with commitsimilar to $ git add . ; git commit -m'Thisisacommitmessage' ; git push# creates a Thisisacommitmessage folder and backups 
# your folders and files inside this new folder 
# this is helpful when you would like to create breakpoints 
backupp path/somepath/somefolder_commit_Thisisacommitmessage
Package: backupper
A simple backup utility. Configurable with a YAML file.Seebackupper-hfor command usage.Allows you to manage backups and encrypt them. You can then usercloneto store them on a distant storage.Installationpip3 install backupperRecommended minimum python version is 3.5. It won’t work with version
3.4 and older.Configuration referenceMinimal backupfile.ymlbackup_dir: /backup/root
artifacts:
    - a/file
    - a/directory
    - /another/directory/
    - et/caeterabackup_dirDefinition:specifies the folder in which the backup directory
will be created. If the folder doesn’t exist, it will be created.Type:relative or absolute path.Mandatory:no, unlessdelete_old_backupsis set totrue.Default value:current working directory.delete_old_backupsDefinition:allows you to delete old backups from the backup
directory specified inbackup_dir. Ifcleaning_policyisn’t
set, all previous backups will be deleted.Type:boolean.Mandatory:no.Default value:false.cleaning_policyDefinition:allows you to define a fine-tuned deletion policy.
Will do nothing ifdelete_old_backupsis set tofalse.Type:at least one of the following parameters.Mandatory:no (if not set, all older backups will be deleted).Each parameter below can be set (at least one). The following schema
visually presents how they work, assuming thiscleaning policy:cleaning_policy:
    most_recents: 2
    first_daily: 1
    first_weekly: 6
    first_monthly: 4Backup management schemaN.B.: please keep in mind that if you increase one of the parameters
between two backups, deleted backups won’t magically pop back from
nowhere. We strongly advise you to be careful with these values.most_recentsDefinition:number of recent backups to keep (in addition to the
current one).Type:natural integer.Mandatory:no.Default value:0.first_dailyDefinition:number of daily backups to keep (keeps the n first
backups of the current day).Type:natural integer.Mandatory:no.Default value:0.first_weeklyDefinition:number of weekly backups to keep (keeps the n first
backups of the current week).Type:natural integer.Mandatory:no.Default value:0.first_monthlyDefinition:number of monthly backups to keep (keeps the n first
backups of the current month).Type:natural integer.Mandatory:no.Default value:0.encryptDefinition:specifies if the backup should be encrypted.
Encryption is performed with GnuPG, so make sure it’s properly
installed on your system.Type:boolean.Mandatory:no.Default value:false.gnupgDefinition:GnuPG configuration.Type:a list of the following parameters.Mandatory:yes, ifencryptis set totrue.homeDefinition:GnuPG home (where keys are stored).Type:string.Mandatory:no.Default value:~/.gnupg.keyidDefinition:GnuPG key identifier (it could be the key id, user
id, key comment…).Type:string.Mandatory:yes.artifactsDefinition:specifies a list of files and folders to backup.Type:a list of absolute or relative paths.Mandatory:yes.
Package: backup-podcasts
backup podcastsMost feature-complete Podcast backup/archive software. Download all available data for all your podcasts, including metadata (RSS, shownote, cover) and supplementary files (transcripts, videos etc.). Intended to be run as a cron-job, skips existing files and never deletes any previous data, even if it's removed from the online podcast.Insallation:pip install backup-podcastsFeatures:OPML importRSS paginationBackup metadata (RSS, shownotes, cover)Graceful interruption behaviour (no half-downloaded files, even when killed)File-system compatible filename sanization (format:pubdate - title)Download all related files (transcripts, videos, etc.)Usage:python -m backup_podcasts --opml "path_to.opml" --destination "/target/backup/location"Destination is optional, defaults to cwd.
Package: backuppurge
Lists files in that should be purged in a backup strategy where daily backups
are kept forDAYSdays, monthly backups forMONTHSmonths and yearly backups
forYEARSyears. Monthly and yearly backups are always the oldest possible
daily backup (e.g. first of month and first of year that is available).Files are expected to have their date embedded asYYYY-MM-DDsomewhere in
the filename, e.g.homedir-2013-03-31.tgzFor monthly and yearly backups, the first day available will be kept (e.g.
January 1st for yearly, but if that is not available, January 2nd will be
kept, etc..).This program can be used together with xargs(1) from GNU findutils:backuppurge --print0 /var/backups/ | xargs -r -0 rmOnly files directly in the specifiedDIRECTORYwill be searched (in the
above example,/var/backups/homedir-2013-03-31.tgzwill be considered,
but not/var/backups/etc/etc-2013-03-31.tgz). This prevents accidental
deletion of files. If –include-directories (-D) is used, directories directly
below the path will be included in the search (e.g. the directory/var/backups/etc-2015-07-24/will be included in the purge search).This script assumes daily backups are FULL backups, not incremental. For
example, a full daily backup of your/etccan be created by adding
(crontab-e) a command like the following to your crontab(5) file:tar czf /var/backups/etc/etc-$(date +%F).tgz /etc
Package: backup.py
BACKUP.PYPyBackup is a recursive/incremental backup utility package written purely in Python. This main feature of the package is its incremental backup which incrementally copies only the files that are added or the parts of the file which are changed. To achieve the later scenario it uses rsync algorithm for which you can find the detailshere.PrerequisitesPython 3.5 or aboveQuick Installpipinstallbackup.pySimple ExampleThis package also installs a script which you can run in the shell as follows:pybackup~/path/to/the/source/dir~/path/to/the/destination/dirOr you can use its Python interface as follows:frombackupimportIncrementalBackupsource_dir="~/path/to/the/source/dir"destination_dir="~/path/to/the/destination/dir"IncrementalBackup(src=source_dir,dst=destination_dir).run()VersioningFor the versions available, see thetags on this repository.LicenseThis project is licensed under the MIT License - see theLICENSEfile for details.AcknowledgmentsThis project was solely inspired byrsync.