Saravanan666/pypi-org huggingface dataset:
Package: polyglotdb
PolyglotDBPolyglotDB is a Python package for storing and querying large speech corpora.  It constructs various kinds of database,
and has a consistent Python API for interacting with the various underlying databases.  The online documentation is
available athttp://polyglotdb.readthedocs.io/en/latest/.This package is intended for developers and those experienced with scripting in Python.  If you would like to use a
graphical interface for querying and interacting with PolyglotDB databases, please see Speech Corpus Tools
(http://speech-corpus-tools.readthedocs.io/en/latest/).  Speech Corpus Tools is currently depreciated and undergoing
significant update to match recent development of PolyglotDB.CitationMcAuliffe, Michael, Elias Stengel-Eskin, Michaela Socolof, Arlie Coles, Sarah Mihuc, and Morgan Sonderegger (2017). PolyglotDB [Computer program]. Version 0.0.1 (alpha), retrieved 28 July 2017 fromhttps://github.com/MontrealCorpusTools/PolyglotDB.orMcAuliffe, Michael, Elias Stengel-Eskin, Michaela Socolof, and Morgan Sonderegger (2017). Polyglot and Speech Corpus Tools: a system for representing, integrating, and querying speech corpora. InProceedings of Interspeech 2017.
Package: polyglotjsonnlp
Polyglot to JSON-NLP(C) 2019 byDamir Cavar, Oren Baldinger, Maanvitha Gongalla, Anurag Kumar, Murali Kammili, Boli FangBrought to you by theNLP-Lab.org!IntroductionPolyglotwrapper forJSON-NLP.
Package: polyglot-piranha
PiranhaFeature flags are commonly used to enable gradual rollout or experiment with new features. In a few cases, even after the purpose of the flag is accomplished, the code pertaining to the feature flag is not removed. We refer to such flags as stale flags. The presence of code pertaining to stale flags can have the following drawbacks:Unnecessary code clutter increases the overall complexity w.r.t maintenance resulting in reduced developer productivityThe flags can interfere with other experimental flags (e.g., due to nesting under a flag that is always false)Presence of unused code in the source as well as the binaryStale flags can also cause bugsPiranha is a tool to automatically refactor code related to stale flags. At a higher level, the input to the tool is the name of the flag and the expected behavior, after specifying a list of APIs related to flags in a properties file. Piranha will use these inputs to automatically refactor the code according to the expected behavior.This repository contains four independent versions of Piranha, one for each of the four supported languages: Java, JavaScript, Objective-C and Swift.It also contains a redesigned variant of Piranha (as of May 2022) that is a common refactoring tool to support multiple languages and feature flag APIs. If interested in this polyglot variant, gotoPolyglot Piranha.To use/build each version, look under the corresponding [lang]/ directory and follow instructions in the corresponding [lang]/README.md file. Make sure to cd into that directory to build any related code following the instructions in the README.PiranhaJavaPiranhaJSPiranhaObjCPiranhaSwiftA few additional links on Piranha:A technicalreportdetailing our experiences with using Piranha at Uber.Ablogpostpresenting more information on Piranha.6 minutevideooverview of Piranha.SupportIf you have any questions on how to use Piranha, please feel free to reach out to us on thegitter channel. For bugs and enhancement requests,open a GitHub issue.ContributorsWe'd love for you to contribute to Piranha!  Please note that once
you create a pull request, you will be asked to sign ourUber Contributor License Agreement.We are also looking for contributions to extend Piranha to other languages (C++, C#, Kotlin).LicensePiranha is licensed under the Apache 2.0 license.  See the LICENSE file for more information.
Package: polyglot-piranha-playground
PiranhaAgentPiranhaAgent uses a static inference algorithm and OpenAI's GPT-4 model to generate human-like piranha rules from code examples.
It generates these rules in TOML format, which can be applied to refactor other parts of the codebase.InstallTo get started with PiranhaAgent, follow these instructions:pip install polyglot-piranha-playgroundUsage (Playground UI)To run the playground:piranha-playgroundTo define your transformation rules, you will need to provide pairs of code snippets: 'before' and 'after' transformation. Each piece of code that needs transformation should be marked by unique identifiers surrounded by comments (like// 1,// 2, etc.). These identifiers serve two purposes:They denote which part of the code should be transformed.They define the transformation sequence, or cascading, i.e., which transformations should follow which.ExampleConsider the following code snippet:Code before refactoring:classSomeClass{// 1 -> 2// 1voidsomeMethod(Stringarg){}// endvoidotherMethod(){Stringx;// 2someMethod(x);// end}}Code after refactoring:classSomeClass{// 1 -> 2// 1publicStringsomeMethod(){}// endvoidotherMethod(){Stringx;// 2x=someMethod();// end}}In this example, there are two transformation points, marked by the identifiers// 1and// 2.// 1shows the transformation fromvoid someMethod(String arg)topublic String someMethod().// 2shows the transformation fromsomeMethod(x)tox = someMethod().The arrow notation// 1 -> 2indicates the transformation cascade, i.e., transformation// 2should be applied after transformation// 1.Each transformation snippet begins with the identifier (like// 1) and ends with a// endcomment.This way of representing transformations helps to create clear, concise, and human-friendly refactoring rules, making it easier to manage and understand your transformations.Make sure to follow these conventions when inputting your code for refactoring. Happy coding!Note: The code before and after must be syntactically correct, and it should parse. Moreover, after applying the rules to code before, the refactored code should match the code after. (spaces are ignored).
Package: polyglots
PolyglotsCreate polyglots for different file typesTo understand better what this does read theexample readmeInstallYou might need to install Tkinter to use it (pre-installed on Windows):sudo apt-get install python3-tk -yFrom PyPIpython3 -m pip install polyglotsFrom GitHub (recommended)python3 -m pip install git+https://github.com/donno2048/polyglotsUseTo use it just run:polyglotsAvailable formats:arj, ar, bmp, cpio, cab, ebml, flac, flv, gif, icc, ico, ilda, java, jp2, jpg, lnk, id3v2, nes, ogg, pcap, pcapng, pe_hdr, pe_sec, png, psd, riff, svg, tiff, wasm, xz, 7z, mp4, pdf, gzip, bzip2, postscript, zip, rar, rtf, dcm, tar, pdfc, iso, id3v1
Package: polyglot-translator
Polyglot - Automate translations with DeepLPolyglot is a CLI tool that automates translation tasks and can be easily integrated into your python softwares.
Using theDeepL API, Polyglot generates a translated file from a given source file.Supported filesPolyglot is born to translateJSONandPOfiles, but now it supports other files. This is the complete list:jsonpo and potdocx (MicrosoftWord)pptx (MicrosoftPowerPoint)html and htmpdfraw text files like .txt or .dat⚠️ If you want to translatePDFs, rember to enable the PDF translations from your DeepL API account.InstallationInstallPythonif you haven't already done so, then usepipto install Polyglot.pipinstallpolyglot-translatorThen you can run Polyglot by running:python-mpolyglotAnd that's all.Soon the whole script will be packaged for other package managers like pacman, apt and brew.UsageThere are four available commands: translate, set_license, print_usage_data and print_supported_languages.Translate"Translate" is the main feature of Polyglot. It reads the passed file and creates one or more new files with the translations. It creates a new file with the translations and doesn't edit the source file.ℹ️ In the case of a PO and POT files, it returns both a PO and an MO file.Command optionsOptionRequiredDescription-s, --source-fileyesThe file to be translated.--to, --target-langyesthe code of the language into which you want to translate the source file-d, --destination-dirnoThe directory where the output file will be located.Will be used the working directory if this option is invalid or not used.--from, --source-langnoSource file language code. Detected automatically by DeepL by default. Specifying it can increase performance and make translations more accurate.Basic usageE.g.: we have a .json source in English and we want to translate it in Italian.python-mpolyglottranslate-sen.json--toITAdvanced usageE.g.: we have a .po source in English and we want a .po file translated into Japanese with the corresponding .mo file in our home. We specify the source language to benefit DeepL.python-mpolyglottranslate-sen.po--toJA-d$HOME--fromEN-USSet DeepL API keyDeepL provides you with a key that allows you to use its API. So, Polyglot requires this key to work and will ask you for it on your first use. You can use the following command to set or change the key manually.python-mpolyglotset-licensePrint usage infoIt returns DeepL usage info related to your API key, run with:python-mpolyglotinfoPrint supported languagesIt returns the list of languages currently supported by DeepL, run with:python-mpolyglotlanguagesDependenciesDeepL PythonColoramaProgressbar 2Polib
Package: polygon-api-access
Polygon API AccessA library for accessing the POLYGON API securely without exposing the Polygon API key.Installationpip install polygon-api-accessGet startedHow to securely access the Polygon API without exposing the Polygon API key.First import class portfolio and then use the library Polygon API Access to instantiate it.Example provided while using the access method to display results for different currencies.frompolygon_api_accessimportPolygonAPIAccessimportosclassportfolio(object):def__init__(self,from_,to):# Initialize the 'From' currency amont to 1self.amount=1self.curr2=0self.from_=from_self.to=to# We want to keep track of state, to see what our next trade should beself.Prev_Action_was_Buy=False# This defines a function to buy the 'To' currency. It will always buy the max amount, in whole number# incrementsdefbuy_curr(self,price):ifself.amount>=1:num_to_buy=floor(self.amount)self.amount-=num_to_buyself.Prev_Action_was_Buy=Trueself.curr2+=num_to_buy*priceprint("Bought%dworth of the target currency (%s). Our current profits and losses in the original currency (%s) are:%f."%(num_to_buy,self.to,self.from_,(self.amount-1)))else:print("There was not enough of the original currency (%s) to make another buy."%self.from_)# This defines a function to sell the 'To' currency. It will always sell the max amount, in a whole number# incrementsdefsell_curr(self,price):ifself.curr2>=1:num_to_sell=floor(self.curr2)self.amount+=num_to_sell*(1/price)self.Prev_Action_was_Buy=Falseself.curr2-=num_to_sellprint("Sold%dworth of the target currency (%s). Our current profits and losses in the original currency (%s) are:%f."%(num_to_sell,self.to,self.from_,(self.amount-1)))else:print("There was not enough of the target currency (%s) to make another sell."%self.to)polygonAPIAccess=PolygonAPIAccess()currency_pairs=[["AUD","USD",[],portfolio("AUD","USD")]]polygonAPIAccess=PolygonAPIAccess(os.getcwd(),"final.db")print(polygonAPIAccess.access(currency_pairs))
Package: polygon-api-access-nn2094
This library is submitted as part of homework-1 to hide polygon key accessInstallationpip install polygon-api-access-nn2094Getting StartedBelow library will be useful to securely access Polygon API. It abstracts the Polygon API key to secure it from getting exposed externally.Take care of the dependencies# dependenciesfrompolygon_accessimportData_Aggregate# Libraries To importimportmath,osExample:Below is a driver code example to test out the working# 4 currency pairs considered for forex exchangecurrency_pairs=[["AUD","USD",[],portfolio("AUD","USD")],["EUR","USD",[],portfolio("EUR","USD")],["USD","INR",[],portfolio("USD","INR")],["USD","PLN",[],portfolio("USD","PLN")]]# Driver codeop=Data_Aggregate(os.getcwd(),'database')# os.getcwd()# this line gets the current working directoryTo print the output after the above function callprint(op.acquire_data_and_write(currency_pairs))
Package: polygon-cli
polygon-cliCommand-line tool forpolygonRequirmentsPython 3 (tested on 3.4)requests libprettytable libcolorama libpyyaml libdiff and diff3 avalible in pathSupported featuresDownload files and solutions from polygon.Uploading them back to polygon.Automatic merging with conflicts.InstallationInstall Python3 and setuputils module (for example, it goes with pip3)Checkout repo usinggit clone https://github.com/kunyavskiy/polygon-cli.gitOn first usage login/password/api_key/api_secret will be asked.
They will be stored locally in plain text.
You may not enter password. If you do that, some features based on html parsion, becuase of lack of api
will not work than.Runpython3 setup.py install [--user]On Linux, it will put the executable polygon-cli in /usr/local/binOn Windows, it will put the executable polygon-cli in Scripts directory of your Python3 installtion. It should be added to the path variable for easier usage.Add the option--userto install as local user without root/administrator privileges.Even if it doesn't run, install the dependencies manually as below,pip3 install requestspip3 install coloramapip3 install prettytablepip3 install pyyaml
Package: polygon-data
Polygon DataA library for fetching real-time forex data from polygon.io and store it into sqlite db.The library has PolygonDataFetch class which has the main function of max code in the fetchData function of library.It also includests_to_datetime(),reset_raw_data_tables(),initialize_raw_data_tables(),initialize_aggregated_tables(),aggregate_raw_data_tables()functions which were the dependency for max christs main funtion.Installationpip install polygon_dataDependencypolygon-api-client==0.2.11

sqlalchemy

datetime

timeGet startedHow to fetch data with this lib?(Note: Make sure you have a directory namedsqliteat the root level)frompolygon_dataimportPolygonDataFetch# Instantiate a PolygonDataFetch objectpolygonDataFetch=PolygonDataFetch()# A dictionary defining the set of currency pairs we will be pulling data forcurrency_pairs=[["AUD","USD",[],portfolio("AUD","USD")],["GBP","EUR",[],portfolio("GBP","EUR")],["USD","CAD",[],portfolio("USD","CAD")],["USD","JPY",[],portfolio("USD","JPY")],["USD","MXN",[],portfolio("USD","MXN")],["EUR","USD",[],portfolio("EUR","USD")],["USD","CNY",[],portfolio("USD","CNY")],["USD","CZK",[],portfolio("USD","CZK")],["USD","PLN",[],portfolio("USD","PLN")],["USD","INR",[],portfolio("USD","INR")]]# Call the fetchData method and pass currency_pairs dictionary as a parameterpolygonDataFetch.fetchData(currency_pairs=currency_pairs)
Package: polygone
polygonepolyglot png file embeddinginspired by and based onhttps://github.com/DavidBuchanan314/tweetable-polyglot-pngexamplepack an mp3 within a zip file into a PNG image:polygonepack-z./test/funkwiki.png./test/virtuabones_smoove.mp3./test/out/poly_funk_1.pngshow the embedded file:7zl./test/out/poly_funk_1.png
Package: polygone-nms
PolyGoneNMSPolyGoneNMS is a library for efficient and distributed polygon Non-Maximum Suppression (NMS) in Python. It supports various NMS methods, intersection calculations, and can handle large numbers of polygons in 1D, 2D, and 3D spaces. PolyGoneNMS uses R-tree data structures and shapely polygon objects for optimal performance.Benchmark PlotsFeaturesEfficient polygon NMS for large numbers of polygons.Support for various NMS methods: Default, Soft, and Class Agnostic.Support for different intersection methods: IOU, IOS, and Dice.R-tree data structure for efficient spatial indexing and querying.Distributed processing support using Ray and Dask.Comprehensive documentation and examples.InstallationYou can install PolyGoneNMS using pip:pipinstallpolygone-nmsQuickstartimportnumpyasnpfrompolygone_nmsimportpolygone_nms# Example input datadata=np.array([[0,0,1,1,0,1,0,0,1,0.9],[0.5,0.5,1.5,1.5,0.5,1.5,0,0,1,0.8],])# Apply NMSresults=nms(data,distributed=None,nms_method="Default",intersection_method="IOU")print("Filtered indices:",results)# Filtered dataprint("Filtered data:")print(data[results])For a more detailed guide on using PolyGoneNMS, please see theQuickstartin the documentation.DocumentationDetailed documentation is available at:ContributingWe welcome contributions to the project! Please follow the usual GitHub process for submitting issues or pull requests.LicenseThis project is licensed under theMIT License.
Package: polygon-etl
Polygon ETL CLIPolygon ETL lets you convert blockchain data into convenient formats like CSVs and relational databases.Full documentation available here.QuickstartInstall Polygon ETL CLI:pip3installpolygon-etlExport blocks, actions and logs (Schema,Reference):>polygonetlexport_blocks_and_transactions--start-block0--end-block500000\--provider-urigrpcs://api.mainnet.polygon.one:443\--blocks-outputblocks.csv--transactions-outputtransactions.csvStream blocks, actions and logs to console (Reference):>pip3installpolygon-etl[streaming]>polygonetlstream--start-block500000-eblock,action,log--log-filelog.txt\--provider-urigrpcs://api.mainnet.polygon.one:443Find other commandshere.For the latest version, check out the repo and call>pip3install-e.>python3polygonetl.pyUseful LinksSchemaCommand ReferenceDocumentationRunning Tests>pip3install-r../requirements_test.txt-e.[streaming]>exportPOLYGONETL_RUN_SLOW_TESTS=true>exportPOLYGONETL_PROVIDER_URI=grpcs://api.mainnet.polygon.one:443
>pytest-vvRunning Tox Tests>pip3install-r../requirements_test.txt
>exportPOLYGONETL_RUN_SLOW_TESTS=true>exportPOLYGONETL_PROVIDER_URI=grpcs://api.mainnet.polygon.one:443
>toxRunning in DockerInstall Dockerhttps://docs.docker.com/install/Build a docker image> docker build -t polygon-etl:latest .
 > docker image lsRun a container out of the image> docker run -v $HOME/output:/polygon-etl/output polygon-etl:latest export_blocks -s 1 -e 5499999 -b 1000 -o outRun streaming to console or Pub/Sub> docker build -t polygon-etl:latest -f Dockerfile .
 > echo "Stream to console"
 > docker run polygon-etl:latest stream --start-block 500000 --log-file log.txt
 > echo "Stream to Pub/Sub"
 > docker run -v /path_to_credentials_file/:/polygon-etl/ --env GOOGLE_APPLICATION_CREDENTIALS=/polygon-etl/credentials_file.json polygon-etl:latest stream --start-block 500000 --output projects/<your-project>/topics/mainnet
Package: polygon-etl-cyberconnect
Polygon ETL CLIPolygon ETL lets you convert blockchain data into convenient formats like CSVs and relational databases.Full documentation available here.QuickstartInstall Polygon ETL CLI:pip3installpolygon-etlExport blocks, actions and logs (Schema,Reference):>polygonetlexport_blocks_and_transactions--start-block0--end-block500000\--provider-urigrpcs://api.mainnet.polygon.one:443\--blocks-outputblocks.csv--transactions-outputtransactions.csvStream blocks, actions and logs to console (Reference):>pip3installpolygon-etl[streaming]>polygonetlstream--start-block500000-eblock,action,log--log-filelog.txt\--provider-urigrpcs://api.mainnet.polygon.one:443Find other commandshere.For the latest version, check out the repo and call>pip3install-e.>python3polygonetl.pyUseful LinksSchemaCommand ReferenceDocumentationRunning Tests>pip3install-r../requirements_test.txt-e.[streaming]>exportPOLYGONETL_RUN_SLOW_TESTS=true>exportPOLYGONETL_PROVIDER_URI=grpcs://api.mainnet.polygon.one:443
>pytest-vvRunning Tox Tests>pip3install-r../requirements_test.txt
>exportPOLYGONETL_RUN_SLOW_TESTS=true>exportPOLYGONETL_PROVIDER_URI=grpcs://api.mainnet.polygon.one:443
>toxRunning in DockerInstall Dockerhttps://docs.docker.com/install/Build a docker image> docker build -t polygon-etl:latest .
 > docker image lsRun a container out of the image> docker run -v $HOME/output:/polygon-etl/output polygon-etl:latest export_blocks -s 1 -e 5499999 -b 1000 -o outRun streaming to console or Pub/Sub> docker build -t polygon-etl:latest -f Dockerfile .
 > echo "Stream to console"
 > docker run polygon-etl:latest stream --start-block 500000 --log-file log.txt
 > echo "Stream to Pub/Sub"
 > docker run -v /path_to_credentials_file/:/polygon-etl/ --env GOOGLE_APPLICATION_CREDENTIALS=/polygon-etl/credentials_file.json polygon-etl:latest stream --start-block 500000 --output projects/<your-project>/topics/mainnet
Package: polygon-forex-aggregate
A simple polygon forex aggregate library using Max Christ’s codethis is only meant for a class project.This library is capable of collecting currency exchange rate from polygon every second and then aggregate every six minutes of data
into a single table entry. The condensed data then can be used to do data processing on top of it.The main loop will continuously collect data for 24 Hours with 10 preset currency exchanges.To use this, simplypip install polygon_forex_aggregateand in your main code, dofrompolygon_forex_aggregateimport*I know this is not the best way to import a package, however, this is the limitation of the code where you need to import everything.
Package: polygon-geohasher
# polygon-geohasherPolygon Geohasher is a Open source Python package which converts apolygon into a set of geohashes with arbitrary precision. Moreconversely, it can obtain the set of geohashes inside a polygon orgeohashes that touch (intersects) the polygon. This library uses[python-geohash](https://pypi.python.org/pypi/Geohash/) and[shapely](http://toblerity.org/shapely/).## RequirementsPolygon Geohasher requires:- Python >= 3.x.- GEOS >= 3.3 (due to shapely).## InstallingLinux users can get Polygon Geohasher from the Python Package Index withpip (8+):`todo``$ pip install polygon-geohasher`## UsageHere are some simple examples:```pythonfrom shapely import geometrypolygon = geometry.Polygon([(-99.1795917, 19.432134), (-99.1656847, 19.429034),(-99.1776492, 19.414236), (-99.1795917, 19.432134)])inner_geohashes_polygon = geohashes_to_polygon(polygon_to_geohashes(test_polygon, 7))outer_geohashes_polygon = geohashes_to_polygon(polygon_to_geohashes(test_polygon, 7, False))````geohash_to_polygon(geohash)`:This function receives a geohash, and returns a Shapely's Polygon.`geohashes_to_polygon(geohashes)`:This function receives a set of geohashes, and returns a Shapely's Polygon or MultiPolygon.`polygon_to_geohashes(polygon, precision, inner(optional))`:This function receives a Shapely's Polygon, the precision of geohashes thatwill be used to create a polygon and returns a set of geohashes(strings) which covers the polygon. It also receives an optionalparameter `inner` that defines the way how those polygons will be created.If inner only contained geohashes will be used, otherwise intersected will.For instance you can see resulted geohashed polygons with both options.![Example](./docs/images/geohashed-polygon-1.jpg)#### DonationsIf you want to make any donation you can send to:- [BTC](bitcoin.org): 1H6VrFKCEabn3rbE9JJUSRXB7PU8Bm4SND- [BCC](bitcoincash.org): 1CmuSwFD9qghEfJ4DdSiRWLxfvK5Srfqsg
Package: polygon-guansli
Installationpip install polygon-guansliGet startedHow to use this package:from get_data import *

# change to your currency pairs
currency_pairs = [["AUD","USD",[],portfolio("AUD","USD")],
                  ["GBP","EUR",[],portfolio("GBP","EUR")],
                   ["USD","CAD",[],portfolio("USD","CAD")]]

main(currency_pairs)
Package: polygon-hw-guansli
Installationpip install polygon-homework-fall-2022Get startedHow to use this package:from get_data import *

# change to your currency pairs
currency_pairs = [["AUD","USD",[],portfolio("AUD","USD")],
                  ["GBP","EUR",[],portfolio("GBP","EUR")],
                   ["USD","CAD",[],portfolio("USD","CAD")]]

# your polygon key
my_key = "your_key"
main(currency_pairs, my_key)