Saravanan666/pypi-org huggingface dataset:
Package: gcalvault
OverviewGcalvault is a command-line utility which exports all of a user's Google Calendars to iCal/ICS format for backup (or portability).Features:Automatically discovers all calendars visible the userDownloads them in iCal/ICS format and saves them to disk for archivalOptionally manages version history for each calendar in an on-disk "vault" (a git repo under the covers)Can be run via Docker image (multi-arch) or installed directly as a Python package with command-line interfaceHow it worksUses Google'sIdentity Providerto authenticate (via OAuth2/OIDC)Uses Google'sCalendar APIto discover a user's calendarsUses Google'sCalDav endpointsto download iCal/ICS calendarsUsesGitPythonto manage local git repo for version history under the coversUsageSome example commands...Sync all calendars forfoo.bar@gmail.comuser:gcalvault sync foo.bar@gmail.comSync one specific calendar:gcalvault sync foo.bar@gmail.com family123@group.calendar.google.comSync only "writable" calendars:gcalvault sync foo.bar@gmail.com --ignore-role readerSimply export calendars, do not save version history:gcalvault sync foo.bar@gmail.com --export-onlySee theCLI helpfor full usage and other notes.InstallationVia Dockerdocker run -it --rm \
    -v ${HOME}/.gcalvault:/root/.gcalvault \
    -v ${PWD}:/root/gcalvault \
    rtomac/gcalvault sync foo.bar@gmail.comVia PyPipip install gcalvault
gcalvault sync foo.bar@gmail.comOAuth2 authenticationThe CLI initiates an OAuth2 authentication the first time it is run (interactive), and then uses refresh tokens for subsequent runs (headless).When you use Gcalvault in its default configuration, you are authenticating with Google using Gcalvault's client ID. There is nothing inherently insecure about this, since the application is running locally and therefore only you will have access to the data it reads from Google.That said, it's strongly recommended to create your own client ID through theGoogle API Console, since the shared client ID will be used by others and subject to limits which may cause unpredictable failures.rclonehas a good write-up onmaking your own client ID.You can provide your client ID and secret to gcalvault as follows:gcalvault sync foo.bar@gmail.com --client-id my_client_id --client-secret my_client_secretDevelopmentSource repository:http://github.com/rtomac/gcalvaultInstall dependencies locally (for IDE)make devenv
. ./.devenv/bin/activateBuild distribution and Docker imagemake buildBuild and test locallymake testBuild and run locallymake run user=foo.bar@gmail.comRelease to PyPi and Docker Hubmake releaseSee targets and variables inMakefilefor more options.LicenseMIT License
Package: gcandle
gcandle 轻量极速的本地量化交易框架目前针对A股。可以做什么使用本框架可以轻松开发出你自己的量化模型。设计良好的API可以让你专注于交易模型的开发，最大限度减小无关的工作量。请看示例项目。
本框架包含数据下载，指标开发，策略回测分析的完整功能。实盘交易暂不包含，本地实盘可以参考easytrader等方案，但量化交易的核心，应该是策略模型。
有了模型，还怕没办法交易么？至于在线方案，我本人是不放心策略安全的。
用本框架开发的模型，可以把选出的股票用其他任何实盘方案实现交易，同时模型却是绝对安全的，因为你对交易软件的输入只会是你模型的结果。轻量代码优雅紧凑，可以轻松看完全部代码，也可轻易扩展功能。极速速度为什么重要，因为策略需要不停的调试。
首先数据在本地。在线方案要做一个复杂的策略模型，对全市场进行扫描计算，几乎是不可能完成的任务，时间太长。
本框架封装了多进程的指标计算，根据主要指标对全市场数据过滤后，保存基本的股票池和策略关心的指标。
这个基本股票池及预计算的指标很重要，因为这之后你应该进入一个调试指标组合及参数优化的循环中，有了这个基础，几年的全市场扫描回测只需要几十秒。你调试策略的速度会大大提高。
当然前提是你的电脑不能太差，对单核cpu就没什么用了。
顺便说下硬件配置推荐：cpu 8核8线程。对计算密集的应用，主要看核心数，多一倍的线程数没用。
内存至少16G，推荐32G，有钱可以64G。
硬盘：如果要做分钟级的策略，至少准备1T的吧，日线级有个500G应该够了。并不是k线数据本身有这么大，而是考虑你的整个系统占用。我现在是1T SSD+3T机械硬盘。
mongodb的存储管理没精通，但目前掌握的是，如果创建了一个很大的集合，drop它之后存储空间仍然没释放，要想减小存储空间占用，就要做一次database repair，repair过程会临时占用大量磁盘空间，所以当mongodb占了你的一半磁盘，你想缩减空间的时候就很麻烦了。为什么做这个框架因为找不到满足我需求的框架，即上述两个条件都满足的。开始使用OS: Linux. Windows还没测试，应该是可以，但是有可能你需要自行解决一些小问题。Python： 3.6.8以上。推荐使用anaconda创建虚拟python环境。请参考官方网站Mongodb：4.0.20以上。推荐一个客户端程序Robo 3T以上都装好了，你可以有两种方法使用gcandle。用pip安装。这种方式会把gcandle的包安装到python环境的site-packages目录下。$ pip install gcandle直接clone本仓库代码，然后在代码根目录运行$ ./install-dev.sh这个命令会用开发方式安装本项目，意思是并不会真正把代码打包放到site-packages下，而是创建一个链接，指向本项目的代码根目录。
好处是，你可以随时修改本项目的代码，在客户端项目中，修改实时生效。以上都搞定，clone这个示例项目，然后尝试跑通，基本就明白怎么用了。
Package: gcandy
drive-candyPython wrapper for Google Drive v3 APITo set up, you have 2 authorization options:Using service account:Create a service account and save the email address and private key and set as environment variables "ISS" and "KEY" or pass to drive constructor.Using your own accountnot yet supportedCreate oauth2 credentials from Google Consolefromdrivecandyimportdrivemy_drive=drive.Drive()
Package: gcapi
Grand Challenge API ClientPython client for the grand-challenge.org REST APIFree software: Apache Software License 2.0FeaturesThis client library is a handy way to interact with the REST API for
grand-challenge.org from python, and provides some convenience methods.
Documentation and examples can be found onGrand
Challenge.TestsThis client is tested using thetoxframework. This enables testing
the client in various python-version environments.For example, running a specificyour_testfor only the python 3.8
environment can be done as follows:tox-epy38---kyour_test
Package: gcapi-python
gcapi-pythonPython package forGain Capital APIused for trading onForex.comTable of ContentsGetting StartedInstallationUsageFunctionsAccount InformationMargin InformationMarket InformationPricingTradingList Open PositionsExamplesContactGetting StartedInstallationpipinstallgcapi-pythonUsageAfter installing, import into your projectfromgcapiimportGCapiClientInitialize withForex.comcredentials and app key.api=GCapiClient(username='usr',password='***',appkey='***',proxies=None)EndpointsAccount Informationapi.get_account_info(get=None)Margin Informationapi.get_margin_info(get=None)Market Informationapi.get_market_info(market_name,get=None)Pricingapi.get_prices(market_id=None,num_ticks=None,from_ts=None,to_ts=None,price_type=None)api.get_ohlc(market_id=None,num_ticks=None,interval="HOUR",span=1,from_ts=None,to_ts=None)Tradingapi.trade_order(quantity,offer_price,direction,trading_acc_id=None,market_id=None,market_name=None,stop_loss=None,take_profit=None,trigger_price=None)List Open Positionsapi.list_open_positions(trading_acc_id=None)ExamplesClickhereto see examplesContactPlease contactKyu Mok (Ricky) Kimif you have any questions, suggestions, or feedback.Website:rickykim.net
Package: gcardvault
OverviewGcardvault is a command-line utility which exports all of a user's Google Contacts in vCard/VCF format for backup (or portability).Features:Automatically discovers all of a user's contactsDownloads them in vCard/VCF format and saves them to disk for archivalOptionally manages version history for each contact in an on-disk "vault" (a git repo under the covers)Can be run via Docker image (multi-arch) or installed directly as a Python package with command-line interfaceHow it worksUses Google'sIdentity Providerto authenticate (via OAuth2/OIDC)Uses Google'sPeople APIto discover a user's contactsUses Google'sCardDAV endpointsto download vCard/VCF contactsUsesGitPythonto manage local git repo for version history under the coversUsageSome example commands...Sync all contacts forfoo.bar@gmail.comuser:gcardvault sync foo.bar@gmail.comSimply export contacts, do not save version history:gcardvault sync foo.bar@gmail.com --export-onlySee theCLI helpfor full usage and other notes.InstallationVia Dockerdocker run -it --rm \
    -v ${HOME}/.gcardvault:/root/.gcardvault \
    -v ${PWD}:/root/gcardvault \
    rtomac/gcardvault sync foo.bar@gmail.comVia PyPipip install gcardvault
gcardvault sync foo.bar@gmail.comOAuth2 authenticationThe CLI initiates an OAuth2 authentication the first time it is run (interactive), and then uses refresh tokens for subsequent runs (headless).When you use Gcardvault in its default configuration, you are authenticating with Google using Gcardvault's client ID. There is nothing inherently insecure about this, since the application is running locally and therefore only you will have access to the data it reads from Google.That said, it's strongly recommended to create your own client ID through theGoogle API Console, since the shared client ID will be used by others and subject to limits which may cause unpredictable failures.rclonehas a good write-up onmaking your own client ID.You can provide your client ID and secret to gcardvault as follows:gcardvault sync foo.bar@gmail.com --client-id my_client_id --client-secret my_client_secretDevelopmentSource repository:http://github.com/rtomac/gcardvaultInstall dependencies locally (for IDE)make devenv
. ./.devenv/bin/activateBuild distribution and Docker imagemake buildBuild and test locallymake testBuild and run locallymake run user=foo.bar@gmail.comRelease to PyPi and Docker Hubmake releaseSee targets and variables inMakefilefor more options.LicenseMIT License
Package: gcbinspy
gcbinspyWrote this to use as a sensor in home assistant so I stop forgetting to take the bins out the night before and inevitably running out in my underwear when the truck wakes me up.Uses same APIhttps://www.goldcoast.qld.gov.au/Services/Waste-recycling/Find-my-bin-dayuses to find your property ID from your address. Alternatively you can manually set your property ID.Example:import gcbinspy

address = "26 Eleventh Ave, Palm Beach QLD 4221"

client = gcbinspy.GoldCoastBins(address)
client.property_id()
client.update_next_bin_days()
print(client.next_landfill().isoformat())
print(client.is_recycling_day())
print(client.is_organics_day_tomorrow())
Package: gccanalyze
Do static analysis with GCC.ExampleOnly interesting shadowing cases are shown:$ gccanalyze bad.cc

bad.cc: In function 'int main()':
bad.cc:5:19: warning: declaration of 'foo' shadows a previous local [-Wshadow]
bad.cc:3:15: warning: shadowed declaration is here [-Wshadow]
bad.cc:5:19: warning: unused variable 'foo' [-Wunused-variable]
Package: gccjit
Python bindings for libgccjit.so (using Cython)Tested with Python 2.7 and 3.2GPLv3 or later.JIT-compiled functions are wrapped up asctypescallables.Prebuilt HTML documentation can be seen athttp://pygccjit.readthedocs.org/en/latest/index.htmlCaveatsMost of the API is wrapped, but not all.Currently the ctypes hack forces all functions to be of type:int foo(int);
Package: gccm
gccmThis is a package designed for causal inference in spatial cross-sectional data.
This Python package is a conversion of the R language code provided in the article "Causal inference from cross-sectional earth system data with geographical convergent cross mapping", with some minor optimizations applied.
You can see more details fromhttps://github.com/spjace/gccm/andhttps://www.nature.com/articles/s41467-023-41619-6
Package: gc-count
rust-gc-countcargobuild--release
target/release/gccount--inputin.fa--outputout.wigDescriptionA tool for generating wiggle files of GC from DNA written in Rust.HelpCalculate GC and write into a wiggle file

Usage: gccount [OPTIONS] --input <INPUT> --output <OUTPUT>

Options:
      --input <INPUT>                   FASTA formatted file (can be gziped) to calculate GC from
      --output <OUTPUT>                 Output wiggle file. One file will be produced
      --window <WINDOW>                 Window size to calculate GC over [default: 5]
      --omit-tail                       Remove any trailing sequence and do not calcualte GC. Default behaviour is to retain the leftover sequence. GC is calculated over the remaining sequence length
      --write-chrom-sizes               Write a chrom.sizes file into the current directory. Use --chrom-sizes-path to configure location
      --chrom-sizes-path <CHROM.SIZES>  Path of the chrom.sizes file. Defaults to chrom.sizes [default: chrom.sizes]
      --verbose                         Be verbose
  -h, --help                            Print help
  -V, --version                         Print versionChecksum calculatortarget/release/checksumseq--inputin.fa--outputchrom.fileAnother binary for calculating sequence lengths and checksums from a file. The resulting file is formted as tab separated with the following columns:Sequence ID as it appears in the FASTA fileSequence lengthRefget ga4gh identifier (SQ.sha512t24u)MD5 checksum hex encodedThe resulting file can be used as achrom.sizesfile too.Command lineIterates through a FASTA file calclating checksums and sequence length

Usage: checksumseq [OPTIONS]

Options:
      --input <INPUT>    FASTA formatted file to calculate checksums from (- mean STDIN). Reads gzipped FASTA if the filename ends with .gz (including bgzip files) [default: -]
      --output <OUTPUT>  Output file (- means STDOUT). Each line is tab separated reporting "ID Length sha512t24u md5" [default: -]
      --verbose          Be verbose
  -h, --help             Print help
  -V, --version          Print versionFrom within PythonPython bindings are available for the checksumseq calculation. The following code demonstrates how to use the bindings.Install the bindingsmaturinis used to build the bindings and install them into the current environment. Ensure you are using the Python environment you want to install the bindings into.pipinstallmaturinThen navigate to therust-gc-count/bindingsdirectory and run the following command to install the bindings.maturinbuild--releaseUse the bindingsTo use the bindings in Python, the following code demonstrates how to use the bindings.fromgc_countimportchecksumresults=checksum("path/to/seq/fasta")forresultinresults:print(result.sha512)Level of code qualityThe code developed here has not been extensively tested but has been verified as producing correct and expected output.
Package: gccoutputparser
gccoutputparserA simple GCC/LLVM (clang) output parser. It reads lines from compiler and
makefile runs, parse, split them and provides parsed information in a
harmonized format.It is possible to configure what you want: access to the pased information?
Counters? Affected files?InstallationSimple install this module via pip (pip for Python 2 is also supported)pip3 install --user gccoutputparserPrefaceGCC sends warnings and errors to standard error while normal output goes to
standard output.Usageimport gccoutputparser

e = gccoutputparser.GccOutputParser(working_directory=os.pwd())
e.feed()

stats = e.statistics()

number_warnings = len(e.warnings())

e.warnings(path_filter='path/matching/in')
Package: gcdb
GCDB is a tool to wrap your ordinary build system by overriding `CC` and `CXX`to allow it to introspect the build process to be able to generate a JSONCompilation Database which can be used with other tools like `clang-tidy`.## Installation```shell$ pip install gcdb```## UsageRun `gcdb` passing in the commands to build your code. You want to ensure theentire sources are built so its important to clear any prior caches. Forexample, if you use `make` to build your code:```shell$ gcdb 'make clean && make'```NOTE: Currently the passed command cannot run concurrently, so you cannot pass`-j` to `make or similiar tools.Home-page: https://github.com/kylef/gcdbAuthor: Kyle FullerAuthor-email: kyle@fuller.liLicense: UNKNOWNDescription: UNKNOWNPlatform: UNKNOWN
Package: gcdevproxy
GoodCam Device ProxyThis library simplifies creating HTTP proxies that can be used to communicate
with GoodCam devices in various networks. GoodCam devices contain abuilt-in clientthat
can be configured to connect automatically to a given proxy. Once
connected, the devices will wait for incoming HTTP requests. The proxy
simply forwards incoming HTTP requests to the connected devices.InstallationThis library is just a wrapper overthe Rust versionof the same
library. You can install this library using pip:pipinstallgcdevproxyIf there is no binary wheel available, pip will try to build also the
underlying Rust library. You will need the Rust compiler installed on your
system to do this. You can install it easily using:curl--proto'=https'--tlsv1.2-sSfhttps://sh.rustup.rs|shSeehttps://www.rust-lang.org/tools/installfor more information.Even though the Rust version of this library can be built for any platform
supported by Rust, this Python wrapper is currently available only for Linux
systems.The Rust version of this library also requires OpenSSL (version 1.0.1 or newer)
or LibreSSL (version 2.5 or newer). Ubuntu/Debian users can install OpenSSL
development files using:sudoapt-getinstalllibssl-devFedora users can install them using:sudodnfinstallopenssl-develUsage exampleThe library supports both blocking and asynchronous API, though the
asynchronous API should be preferred due to a better performance. To use the
asynchronous API, simply use thecreate_proxyandRequestHandlerequivalents from thegcdevproxy.aiomodule.Please keep in mind thatwhen using the blocking API, your request handler
MUST be thread-safe!The proxy runtime may call your handler from multiple
threads at the same time. You don't have to worry about this when using the
asynchronous API because your handler will be called only from the thread
running the Python's asyncio event loop (usually the main thread).Asynchronous APIfromgcdevproxy.aioimportRequestHandler...classMyRequestHandler(RequestHandler):asyncdefhandle_device_request(self,authorization:Authorization)->'DeviceHandlerResult':...asyncdefhandle_client_request(self,request:Request)->'ClientHandlerResult':...asyncdefmain():config=ProxyConfig()config.http_bindings=[('0.0.0.0',8080)]config.request_handler=MyRequestHandler()proxy=awaitgcdevproxy.aio.create_proxy(config)awaitproxy.run()if__name__=='__main__':asyncio.run(main())Blocking APIfromgcdevproxyimportRequestHandler...classMyRequestHandler(RequestHandler):defhandle_device_request(self,authorization:Authorization)->'DeviceHandlerResult':...defhandle_client_request(self,request:Request)->'ClientHandlerResult':...defmain():config=ProxyConfig()config.http_bindings=[('0.0.0.0',8080)]config.request_handler=MyRequestHandler()proxy=gcdevproxy.create_proxy(config)proxy.run()if__name__=='__main__':main()More examplesSee theexamplesdirectory in the root of this repository for ready-to-use
examples.
Package: gc-django-redis-sessions
django-redis-sessions=======================Redis database backend for your sessions.. image:: https://travis-ci.org/martinrusev/django-redis-sessions.svg?branch=master:target: https://travis-ci.org/martinrusev/django-redis-sessions------------Installation------------1. Run ``pip install django-redis-sessions`` or alternatively  download the tarball and run ``python setup.py install``,For Django < 1.4 run ``pip install django-redis-sessions==0.3``2. Set ``redis_sessions.session`` as your session engine, like so::SESSION_ENGINE = 'redis_sessions.session'3. Optional settings::SESSION_REDIS_HOST = 'localhost'SESSION_REDIS_PORT = 6379SESSION_REDIS_DB = 0SESSION_REDIS_PASSWORD = 'password'SESSION_REDIS_PREFIX = 'session'# If you prefer domain socket connection, you can just add this line instead of SESSION_REDIS_HOST and SESSION_REDIS_PORT.SESSION_REDIS_UNIX_DOMAIN_SOCKET_PATH = '/var/run/redis/redis.sock'4. That's it::See: `django-redis-sessions <http://pypi.python.org/pypi/django-redis-sessions>`_ on pypi5. Tests::$ pip install django nose redis# Make sure you have redis running on localhost:6379$ nosetests
Package: gc-docker-py
docker-py=========[![Build Status](https://travis-ci.org/docker/docker-py.png)](https://travis-ci.org/docker/docker-py)An API client for docker written in PythonInstallation------------Our latest stable is always available on PyPi.pip install docker-pyDocumentation------------[![Documentation Status](https://readthedocs.org/projects/docker-py/badge/?version=latest)](https://readthedocs.org/projects/docker-py/?badge=latest)Full documentation is hosted on [ReadTheDocs](http://docker-py.readthedocs.org/en/latest/).Sources are available in the `docs/` directory.License-------Docker is licensed under the Apache License, Version 2.0. See LICENSE for full license text
Package: gcdt
glomex-cloud-deployment-tools (gcdt)gcdt CLI tools make it easy for you to code, automate, and deploy your
AWS infrastructure.The gcdt command line tools have emerged from our experiences at glomex
while working extensively with AWS services like Cloudformation,
CodeDeploy, AWS Lambda, and API Gateway. gcdt is based on the same
technology AWS uses to build AWS-CLI and Boto3 tools.In 2017 glomex won the Gartner award “Best Data Management and
Infrastructure”. Key to our success are the gcdt CLI tools we use to
successfully complete >3000 deployments per month to AWS. Over the
course of the last 18 months we built gcdt ourselves using Python.Features include:Infrastructure-as-codeCloud infrastructure (kumo & tenkai)Serverless infrastructure (ramuda & yugen)ScaffoldingPowerful plugin mechanismService integration (Slack, Datadog, …)Codify infrastructure best practicesMulti-Env support (dev, stage, prod, …)At glomex we lovecontinuous-integration-as-codeandinfrastructure-as-code. This enables us to move fast while providing
services of high quality and resilience to our partners.We added a plugin mechanism to gcdt so we can specialize gcdt to highly
optimized and opinionated environments that resonate with our usecases.We hope gcdt will be helpful to you, too. At glomex we believe that only
open source software can become truly great software.Why gcdt?You can do everything gcdt does by using the AWS Management Console so
why use gcdt? Basically, because using GUI interfaces to drive your
production environment is a really bad idea. You can’t really automate
GUI interfaces, you can’t debug GUI interfaces, and you can’t easily
share techniques and best practices with a GUI.The goal of gcdt is to put everything about your AWS infrastructure into
files on a filesystem which can be easily versioned and shared. Once
your files are in git, people on your team can create pull requests to
merge new changes in and those pull requests can be reviewed, commented
on, and eventually approved. This is a tried and proven approach that
has worked for more traditional deployment methodologies and will also
work for your infrastructure on AWS.Useful gcdt informationgcdt_userguidegcdt issuesgcdt project boardInstallationFollow theinstructionsto installgcdtContributingHere you can find the full guide forcontributingAt glomex we welcome feedback, bug reports, and pull requests!For pull requests, please stick to the following guidelines:Add tests for any new features and bug fixes. Ideally, each PR should
increase the test coverage.Follow the existing code style. Use PEP8 code linting.Put a reasonable amount of comments into the code.Separate unrelated changes into multiple pull requests.LicenseCopyright (c) 2017 glomex and others. gcdt is released under the MIT
License (see LICENSE).
Package: gcd-talker
Grand Comics Database™ plugin for Comic TaggerA plugin forComic Taggerto allow the use of the metadata fromGrand Comics Database™.Obtaining the SQLite DBCreate an account on theGCD.Download the latest SQLite3 dump of their DB (minus images and image URLs) athttps://www.comics.org/download/Cover imagesGCD does not make their image URLs available via their DB dumpsAn option is available to attempt to download the covers in the GUI and separately for auto-tagging.
Due to occasional CloudFlare activation, images may not download.Installpip install .
Package: gcdt-bundler
Plugin for gcdtauthor: glomex SRE Team gcdt:https://github.com/glomex/gcdtFeatures include:bundle artifacts (zip file) for tenkai and ramudaRunning testsPlease make sure to have good test coverage for your plugin so we can
always make sure your plugin runs with the upcoming gcdt version.Run tests like so:$python-mpytest-vv--cov-reportterm-missingtests/test_*LicenseCopyright (c) 2017 glomex and others. gcdt and plugins are released
under the MIT License (see LICENSE).
Package: gcdt-config-reader
Plugin for gcdtauthor: glomex SRE Team gcdt:https://github.com/glomex/gcdtFeatures include:read gcdt_.json and gcdt_.py config filesRunning testsPlease make sure to have good test coverage for your plugin so we can
always make sure your plugin runs with the upcoming gcdt version.Run tests like so:$python-mpytest-vv--cov-reportterm-missingtests/test_*LicenseCopyright (c) 2017 glomex and others. gcdt and plugins are released
under the MIT License (see LICENSE).