Saravanan666/pypi-org huggingface dataset:
Package: greendeck-timeseries
greendeck-timeseriesCreated for internalGreendeckuse only. Can be used for non-commercial purposes.How to build your pip packageopen an account herehttps://pypi.org/In the parent directorypython setup.py sdist bdist_wheeltwine upload dist/*referenceshttps://medium.com/small-things-about-python/lets-talk-about-python-packaging-6d84b81f1bb5Thank You
Package: greendeck-time-series
greendeck-timeseriesCreated for internalGreendeckuse only. Can be used for non-commercial purposes.How to build your pip packageopen an account herehttps://pypi.org/In the parent directorypython setup.py sdist bdist_wheeltwine upload dist/*referenceshttps://medium.com/small-things-about-python/lets-talk-about-python-packaging-6d84b81f1bb5Thank You
Package: greendeck-timeseries-gen
greendeck-timeseriesCreated for internalGreendeckuse only. Can be used for non-commercial purposes.How to build your pip packageopen an account herehttps://pypi.org/In the parent directorypython setup.py sdist bdist_wheeltwine upload dist/*referenceshttps://medium.com/small-things-about-python/lets-talk-about-python-packaging-6d84b81f1bb5Thank You
Package: greendeploy-cli
GreenDeployGreenDeploy is a framework that makes it easy to build Dockerized Django projects
by providing uniform templates.This is mostly a cli software.Release Schedulepy3.8 will be onto-be-frozenstatus starting 2022-10. This serves as a 1 year countdown tofrozenstatus where it will no longer be supportedpy3.8 will be supported till 2023-10 after which it will be onfrozenstatus and removed from main brach and no longer supported.py3.9 will be onto-be-frozenstatus starting 2023-10. This serves as a 1 year countdown tofrozenstatus where it will no longer be supportedSo the full schedule for this package isPythonaddto-be-frozenstatusfrozenstatus and stop supportingPSF start releasePSF stop full supportPSF stop security fix3.8since package inception2022-102023-102019-102021-052024-103.9since package inception2023-102024-102020-102022-052025-103.10(latest)since package inception2024-102025-102021-102023-052026-103.11(preview)2023-042025-102026-102022-102024-052027-10How to installMinimum python version: 3.9Recommended to have a venv running python 3.9 before you runpip install greendeploy-cliLatest greendeploy-cli version is 0.0.11Watch asciicast on installation for v0.0.9. Steps are the same.How to useCheck infogreendeploy infoCreate a new Dockerized Django project from startergreendeploy new --verboseThe starter is fromhttps://github.com/GreenDeploy-io/greendeploy-starters/tree/main/starters/dockerized-django/defaultWatch asciicast on creating new project locally on desktop
Requires: Docker and Docker ComposeWatch loom on how it should look like at first webpage load after firstnewcommandRelated Docker commandsTo bring up the docker containers locallydocker-compose -f local.yml upTo stop the docker, use control + CTo bring down the docker containers locallydocker-compose -f local.yml down --remove-orphans
Package: greendns
greendnsA DNS recursive resolve server to avoid result being poisoned and friendly to CDN. It will qeury dns servers at the same time and don't wait for all responses. It's more efficient and quicker thanChinaDNS.CDN-friendly means the resolved IP is the best(Same ISP and the nearest). The Foreign DNS with edns-client-subnet returned IP is not that accurate, especially for the local small ISP.You must config at least two dns servers. One part is local and poisoned, the other part is unpoisoned(tunnel through VPN or use OpenDNS 443/5353 port,dnscrypt-proxyis recommended).How it worksFirst filter poisoned ip with blocked iplist with -b argument.
Second,
                                       | A record is local | A record is foreign
    local and poisoned dns server      |    a              |   b
    unpoisoned dns server              |    c              |   d

From the matrix, we get the result as follows,
ac: use local dns server result
ad: use local dns server result
bc: impossible. use unpoisoned dns server result
bd: use unpoisoned dns server result

Conclusion,
Using local dns server result if returned A record is local.
Using unpoisoned dns server result if returned A record is Foreign.It has two assumptions,the polluted domain is foreign.the A record in poisoned response is foreign.InstallpipinstallgreendnsRunterminal commandgreendns-rgreendnsdaemon servicego toservicesDockerfilego togreendns-containerdocker stack (recommended)go togreendns-stackTestdigwww.google.com@127.0.0.1-p1053Configuregreendns-rgreendns-h
usage:greendns[-h][-rHANDLER][-pPORT][-tTIMEOUT][-lLOGLEVEL][-mMODE][--ldsLDS][--rdsRDS][-fLOCALROUTE][-bBLACKLIST][--rfc1918][--cache]optionalarguments:-h,--help-rHANDLER,--handlerHANDLERSpecifyhandlerclass,greendns|quickest(default:None)-pPORT,--portPORTSpecifylistenportorip(default:127.0.0.1:1053)-tTIMEOUT,--timeoutTIMEOUTSpecifyupstreamtimeout(default:1.5)-lLOGLEVEL,--log-levelLOGLEVELSpecifyloglevel,debug|info|warning|error(default:info)-mMODE,--modeMODESpecifyioloopmode,select|epoll(default:select)--ldsLDSSpecifylocalpoisoneddnsservers(default:223.5.5.5:53,114.114.114.114:53)--rdsRDSSpecifyunpoisoneddnsservers(default:tcp:208.67.222.220:5353,9.9.9.9:9953)-fLOCALROUTE,--localrouteLOCALROUTESpecifylocalroutesfile(default:/home/etc/greendns/localroute.txt)-bBLACKLIST,--blacklistBLACKLISTSpecifyipblacklistfile(default:/home/etc/greendns/iplist.txt)--rfc1918Specifyifrfc1918ipislocal(default:False)--cacheSpecifyifcacheisenabled(default:False)Perfbenchmark resultperf.mdprofileprof.mdAcknowledgements@clowwindy: the author of theChinaDNSLicenseThis project is under the MIT license. See theLICENSEfile for the full license text.
Package: green-eggs
Green EggsAboutThis is a library/framework that you can use to easily create a channel chatbot with Python code.It is intended to be very quick and simple to set up and use, and either be stopped and started whenever, or stay
running indefinitely.UsageSeeexample.pyfor an example bot setup. That's all
there is for now, more in-depth documentation is coming soon.bot.register_basic_commandsis a function that takes a mapping of first word invoke to response strings.bot.register_commandis a decorator that takes a first word invoke and decorates a function that's called when the
command is run.Notice in the example that this can be a sync or async function.The parameters must be accessible by keyword, and the value depends on the name of the keyword.FeaturesA robust IRC client that ensures that expected responses to actions have happened, such as joining and leaving a
channel, and reconnects or fails as necessary.Cool-downs on commands, per user and global.A Helix API accessor with functions for each documented endpoint, fully typed for URL parameter and payload body
values.An expandable way of specifying how messages trigger command, beyond just the first word being!command.A complete suite of dataclasses to represent all possible data that comes through the IRC chat. This allows for robust
typings.Link detection and purging, complete with configurable allow conditions of link target and user statusLink target allowing works on domain and/or path string or regex matchingCurrently, user conditions are only subscriber or VIP or eitherFeatures soon comingA suite of SQLAlchemy models to save incoming data from IRC, with columns to match the dataclasses.Eventual future featuresA way to write the bot with a config file and/or a python file.API result caching to prevent rate limiting.A suite of CLI options to quickly make API calls and database queries.Webhooks for handling events that don't come through in chat, and better handling of events that do.
Package: green-energy
green_energyA python library to access the Awattar Api. Refer also to theAwattar Energy Price API. This repo provides functionality for:Getting Energy Price forecast information.Installing the library locallyPython 3 is recommended for this project.python-mpipinstall-e.This is needed for the first time when working with the library/examples/tests.Example usageENERGY_DATA_API_URL="https://api.awattar.de"python3examples/simple.pyorfromgreen_energy_api.green_energy_apiimportGreenEnergyApigreen_energy_api=GreenEnergyApi('provide_api_url')# or you can define additional optional parameters# green_energy_api = GreenEnergyApi('provide_api_url', timeout=10)print(green_energy_api.get_electricity_price())DevelopmentInstalling required pip packagespythonpipinstall-rrequirements.txt
pre-commitinstall-tpre-pushLintingpylintgreen_energy_api/*.pytests/*.pyexamples/*.pyUnit testingpytesttests/*.py# show logspytest-olog_cli=true# code coveragepytest--durations=10--cov-reportterm-missing--cov=green_energy_apitests
Package: green-energy-api
green_energy_apiA python library to access the Awattar Api. Refer also to theAwattar Energy Price API. This repo provides functionality for:Getting Energy Price forecast information.Installing the library locallyPython 3 is recommended for this project.python-mpipinstall-e.This is needed for the first time when working with the library/examples/tests.Example usageENERGY_DATA_API_URL="https://api.awattar.de"python3examples/simple.pyorfromgreen_energy_api.green_energy_apiimportGreenEnergyApigreen_energy_api=GreenEnergyApi('provide_api_url')# or you can define additional optional parameters# green_energy_api = GreenEnergyApi('provide_api_url', timeout=10)print(green_energy_api.get_electricity_price())DevelopmentInstalling required pip packagespythonpipinstall-rrequirements.txt
pre-commitinstall-tpre-pushLintingpylintgreen_energy_api/*.pytests/*.pyexamples/*.pyUnit testingpytesttests/*.py# show logspytest-olog_cli=true# code coveragepytest--durations=10--cov-reportterm-missing--cov=green_energy_apitests
Package: greenenv
greenenv Context ManagerContext manager controls venv allowing functions to be run in a different interpreter.Free software: ISC licenseDocumentation:https://greenenv.readthedocs.org.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.0.1 (2016-04-21)First release on PyPI.
Package: greeneye_monitor
Receive data from yourGreenEye Monitorin Python.This module provides a layered API for parsing individual packets (greeneye.packets), processing streams of packets
(greeneye.streams), or monitoring the current state reported by one or more monitors (greeneye.monitor). It’s an
API intended to be integrated with other systems; it does not itself provide those integrations or any sort of data
storage. If you’re looking for something like that, check outbtmon.py.Features include:
* Parsing for all binary packet formats
* Receive data from multiple monitors
* Computes rate-of-change (Watts, pulses/sec) in addition to reporting total valuesQuick startAPI UsageSeedump_packets.pyfor a simple usage example.GEM SetupYour GEM must be set to send binary format packets (formats that begin with Bin, e.g. Bin32 NET) to
the IP address of the computer on which you’re running this software.
YourGEM configuration manualis the canonical source for how to do this, but here are the steps as of this writing:Navigate to your GEM’s web UI (http://<GEM IP>:8000)Click “Enter Setup Mode”Click the “Packet Send” tabSet the “Primary (Com1) Packet Format” to one of the “Bin” formats. I recommend:Bin32 ABS if you have a 32-channel GEM with no channels set for net meteringBin32 NET if you have a 32-channel GEM and some channels are set for net meteringBin48 ABS if you have a 48-channel GEM with no channels set for net meteringBin48 NET if you have a 48-channel GEM and some channels are set for net meteringSet the “Packet Send Interval” if you want something other than the defaultClick “Save”Click the “Network” tabEnter the IP address of the computer on which you’ll be running this software, and the port of your choiceClick “Save”Click “Return” when it becomes availableClick “Exit Setup Mode”
Package: green-face-recognition
[GreenLabs] - Face RecognitionThis library written in MXNET framework.Author:HungLVLast Update:July 13, 2020It features:Face DetectionExtract Face EmbeddingSearch Face in databaseCode:Documentation:User-Guide:Model zoo:Tech report:What's new[Jul 9]Initial version[Jul 13]Make the models can run on GPU/CPU. Integratedrcnnlibrary.InstallationMake surecondais installedpip install green-face-recognitionGetting startedPrepare the config file asyamltype. Take a lookthis example.Show the list of modelsfromface_recognitionimportmodelsmodels.show_avai_models()Load the modelsretina_model=models.build_model('retina-r50',config_path)arcface=models.build_model('arc-face',config_path)Make the prediction# get faces and landmarksretina_model.detect_fast(img,img.shape,0.8,[1],do_flip=False)AppendixGenerate the distributions for uploading to serverpython3 setup.py sdist bdist_wheelUpload to serverpython3 -m twine upload --repository pypi dist/*Reference1. RetinaFaceModel
Package: greenflare
Greenflare SEO Web CrawlerGreenflare is a lightweight free and open-source SEO web crawler for Linux, Mac, and Windows, and is dedicated to delivering high quality
SEO insights and analysis solutions to the world.FeaturesCross-platform (Linux, Mac, and Windows)Low hardware requirementsScalable (tested against sites with 4M+ URLs)Reports on on-page SEO elements (i.e. page title, meta robots, canonical tag)Analysis of HTTP header responses (i.e. X-Robots-Tag, Canonical HTTP Header)Status code reporting (i.e. 301, 404, 503 etc.)robots.txt parser (implemented against the suggested REP standard by Google)Custom extraction through XPath or CSSCustom exclusion of URLs through various patternsQuick filtering and sorting of crawl dataView broken internal links (3xx, 4xx, 5xx)Greenflare databases (.gflaredb) are sqlite tablesExport any view to CSVGetting StartedThe quickest way to get started using Greenflare is to download one of
our pre-built installers. Choose the version for your OS from our Download page:https://greenflare.io/downloadPython PackageGreenflare is also available as a pypi package:pip install greenflareThe use of a virtual environment (venv) is recommended.
Linux users may chose to install ttkthemes for an improved visual experience.DevelopersAre you interested in becoming more involved in the development of
Greenflare? Please submit a pull request if you want to help to build new amazing features or to fix nasty bugs!
Alternatively, please email ben at greenflare dot ioReport a bugPlease report bugs by creating a new issue directly on GitHub:https://github.com/beb7/gflare-tk/issues
Package: greenflow
greenflow - Graph Computation ToolkitWhat is greenflow?greenflow is a tool that helps you to organize the workflows.It define a TaskGraph file format.gq.yamlthat describes the workflow. It can be edited easily bygreenflowlabJupyterLab plugin.Dynamically compute the input-output ports compatibility, dataframe columns names and types, ports types to prevent connection errors.Nodes can have multiple output ports that can be used to generate different output types. E.g. some data loader Node provides bothcudfanddask_cudfoutput ports. The multiple GPUs distributed computation computation is automatically enabled by switching to thedask_cudfoutput port.Provides the standard API to extend your computation Nodes.The composite node can encapsulate the TaskGraph into a single node for easy reuse. The composite node can be exported as a regular greenflow node without any coding.greenflow can be extended by writing a plugin with a set of nodes for a particular domain. Checkpluginsfor examples.These examples can be used as-is or, as they are open source, can be extended to suit your environments.Binary pip installationTo install the greenflow graph computation library, run:pipinstallgreenflowOr installgreenflowat the root directory:pipinstall.greenflow node plugins can be registered in two ways:(Recommended)Write a external plugin using 'entry point' to register it. Check theexternaldirectory for detailsRegister the plugin ingreenflowrcfile. Check theSystem environmentfor detailsSystem environmentThere are a few system environment that the user can overwrite.The custom module files are specified in thegreenflowrcfile.GREENFLOW_CONFIGenviroment variable points to the location of this file. By default, it points to$CWD\greenflowrc.In the examplegreenflowrc, system environment variableMODULEPATHis used to point to the paths of the module files.
To start the jupyterlab, please make sureMODULEPATHis set properly.
Package: greenformatics-ds2-utils
This is a utility package to support data scraping from different data sources like RESTand SOAP APIs, Google Sheets, online CSV files, databases including SQL, NoSQL and LDAP etc.The goal of this package to get all the necessary utilities together, maintain them in a singlecode base and make the available for all the data scraping project from PyPi hence it isupgradeable in a particular data scraper program.
Package: greenformer
GreenformerAutomatic factorization library for pytorchIf you use any source codes included in this toolkit in your work, please cite the following paper.Winata, G. I., Cahyawijaya, S., Lin, Z., Liu, Z., & Fung, P. (2020, May). Lightweight and efficient end-to-end speech recognition using low-rank transformer. In ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP) (pp. 6144-6148). IEEE.What is GreenformerGreenformer is a library to convertLinear,Conv1d,Conv2d,Conv3dlayers into its own variant which calledLED.
Greenformer seeks over your PyTorch module, replace allLinearlayers intoLEDlayers and allConv1d,Conv2d,Conv3dlayers intoCEDlayers with the specified rank.How to Installpip install greenformerUsageBERT Modelfrom transformers import BertModel, BertConfig
from greenformer import auto_fact

config = BertConfig.from_pretrained('bert-base-uncased', pretrained=False)
model = BertModel(config=config)

model = auto_fact(model, rank=100, deepcopy=False, ignore_lower_equal_dim=True, fact_led_unit=False)VGG Modelimport torch
from torchvision import models
from greenformer import auto_fact

model = models.vgg16()
model = auto_fact(model, rank=64, deepcopy=False, ignore_lower_equal_dim=True, fact_led_unit=False)Why Use GreenFormerImprove the speed of you model significantly, check ourExample NotebookMantain model performance with appropriate choice of rank, check ourICASSP 2020 PaperEasy to use and works on any kind of model!
Package: greengen
GreengenGreengen is a python package that allows implementing generators without yielding items all the way up.
Instead, any inner function called from a greengen generator, can yield items directly to the outer generator.Installationpip install greengenUsageFor example, suppose we want to implement a function that performs some heavy business logic, and generates logs.
We want to handle the logs the moment they are created.
But our function has to call a deep stack of helper functions, which in their turn call more functions,
and logs may be written anywhere inside any function.
The implementation with regular generators will be utterly annoying:importtimedefdo_business_logic_and_yield_logs(some_input):yield from_helper_function(some_input)yield from_more_helper_function(some_input)def_helper_function(some_input):foriinrange(some_input):logs_and_result=_inner_helper_function(i)# Notice the enormous effort needed in order to retrieve the last result (using StopIteration etc.)whileTrue:try:yieldnext(logs_and_result)# This is a logexceptStopIterationase:result=e.value# This is the resultyieldlog('Result for{}is{}'.format(i,result))breakdef_more_helper_function(some_input):yield from_helper_function(some_input*100)yield from_helper_function(some_input**2)def_inner_helper_function(some_input):yieldlog('Started calculating')result=2**some_input# (Or whatever other heavy calculation)yieldlog('Finished calculating')returnresult# Will be raised as StopIterationdeflog(stuff):return{'message':str(stuff),'timestamp':time.time()}defmain():forlindo_business_logic_and_yield_logs(42):# Consume the logs however we wantprint('{}:{}'.format(l['timestamp'],l['message']))Using Greengen, this example can be simplified into the following:importtimeimportgreengen@greengen.greengendefdo_business_logic_and_yield_logs(some_input):# Notice how we don't need the "yield from" anymore_helper_function(some_input)_more_helper_function(some_input)def_helper_function(some_input):foriinrange(some_input):# Notice how easy it is to retrieve the result nowresult=_inner_helper_function(i)log('Result for{}is{}'.format(i,result))def_more_helper_function(some_input):_helper_function(some_input*100)_helper_function(some_input**2)def_inner_helper_function(some_input):log('Started calculating')result=2**some_input# (Or whatever other heavy calculation)log('Finished calculating')returnresultdeflog(stuff):# This is the only place in the entire code where we need to be aware of the fact that we are inside a generator.# This will directly yield the log as the next item in the outer generator ("do_business_logic_and_yield_logs")greengen.yield_({'message':str(stuff),'timestamp':time.time()})defmain():forlindo_business_logic_and_yield_logs(42):# Consume the logs however we wantprint('{}:{}'.format(l['timestamp'],l['message']))ContributingFork it!Create your feature branch:git checkout -b my-new-featureCommit your changes:git commit -am 'Add some feature'Push to the branch:git push origin my-new-featureSubmit a pull request :DHistoryTODO: Write historyCreditsTODO: Write creditsLicenseTODO: Write license
Package: greengrasssdk
The AWS IoT Greengrass Core SDK is meant to be used by AWS Lambda functions running on an AWS IoT Greengrass Core. It will enable Lambda functions to invoke other Lambda functions deployed to the Greengrass Core, publish messages to the Greengrass Core and work with the local Shadow service.Using AWS IoT Greengrass Core SDKTo use the AWS IoT Greengrass Core SDK, you must first import the AWS IoT Greengrass Core SDK in your Lambda function as you would with any other external libraries. You then need to create a client for ‘iot-data’ or ‘lambda’. Use ‘iot-data’ if you wish to publish messages to the local Greengrass Core and interact with the local Shadow service. Use ‘lambda’ if you wish to invoke other Lambda functions deployed to the same Greengrass Core.Here is an example for using the ‘iot-data’ clientimportgreengrasssdk# Let's instantiate the iot-data clientclient=greengrasssdk.client('iot-data')Now that you have aniot-dataclient, you can publish requests.response=client.publish(topic='someTopic',payload='some data'.encode())Here is an example for using the ‘lambda’ client.importgreengrasssdkclient=greengrasssdk.client('lambda')Now that you have a lambda client, you can publish requests.# Define the payload to pass to the invoked lambda functionmsg=json.dumps({'message':"hello"})# Invoke the lambda functionresponse=client.invoke(FunctionName='arn:<partition>:lambda:<region>:<account id>:function:<function name>',InvocationType='RequestResponse',Payload=payload,Qualifier='2')CompatibilityAs new features are added to AWS IoT Greengrass, newer versions of the AWS IoT Greengrass SDK may be incompatible with older versions of the AWS IoT Greengrass core. The following table lists the compatible SDKs for all GGC releases.GGC VersionCompatible SDK Versions1.0.x-1.6.x1.0.x-1.2.x1.7.x-1.8.x1.0.x-1.3.x1.9.x1.0.x-1.4.x1.10.x1.0.x-1.5.x1.11.x1.0.x-1.6.xStream ManagerGreengrass version 1.10 comes with a new optional feature, Stream Manager. This SDK supports Stream Manager, but it has additional requirements. Specifically, Stream Manager requires Python version 3.7 or above. It also has package requirements listed in the requirements.txt file. Please install these requirements and bundle it with your lambda zip package.To install the requirements you can use pip such aspip install --target . -r requirements.txt. This will install the requirements to the directory that you run the command in. In order to work in Greengrass the dependencies must be bundled in the zip with your lambda code.
With the pip command above, the dependencies will be installed to the current directory. The dependencies must be bundled with your lambda code, so if the current directory doesn’t have your
lambda code, then simply copy the installed dependencies to the directory which contains your code.