Saravanan666/pypi-org huggingface dataset:
Package: greatapi
GreatAPI - Full-stack FastAPI FrameworkGreatAPI is a full-stack FastAPI framework designed to simplify and accelerate web application development. It leverages the power of FastAPI and integrates various essential tools to provide a seamless development experience.DocumentationExplore our comprehensive documentation to get started with GreatAPI:DocumentationSource CodeFind the source code on GitHub:GitHub RepositoryPyPI PackageInstall GreatAPI using PyPI:PyPI PackageContributorsMajor contributors to GreatAPI:@thebrowl-> Admin Panel Design@lamdiv-> Admin Panel Development with Jinja2@Avi777-> ConsultantRequirementsBefore we dive into the tutorial, make sure you have the following requirements in place:Python 3.6 or higher installed on your system.Familiarity with Python programming language concepts.GreatAPI is built upon the foundation of the following robust libraries:FastAPI: A modern, fast, web framework for building APIs with Python.uvicorn: ASGI server that runs FastAPI applications.typer: A command-line interface library for building CLI applications.jinja2: A templating engine for Python.SQLAlchemy: A powerful Object-Relational Mapping (ORM) library for Python.InstallationTo install GreatAPI and its dependencies, usepip:pipinstallgreatapiGetting StartedStep 1: Start a New ProjectTo begin working with GreatAPI, let's create a new project. Open your terminal and execute the following command:greatapistartprojectmyprojectThis will create a new directory named "myproject" with the basic structure to get you started.myproject/

├──__init__.py

├──settings.py

main.pyStep 2: Create a New AppAn app in GreatAPI is a modular unit that encapsulates specific functionality of your project. To create a new app, run the following command:greatapistartappmyappThis will generate a new directory named "myapp" containing the necessary files and folders for your app.myapp/

├──__init__.py

├──models.py

├──repository.py

├──router.py

├──schemas.pyStep 3: Run the ServerNow, it's time to run the development server. Execute the following command:greatapirunserverStep 4: Creating a SuperuserAfter running the server, let's create a superuser to manage the administration of your project. Execute the following command:greatapicreatesuperuserFollow the prompts to create the superuser account and again run the server.The server will start, and you can access your application athttp://localhost:8000/. Additionally, GreatAPI provides a beautifully designed built-in Admin Panel accessible athttp://localhost:8000/admin.
Package: great_asset
GreatAssetWelcome, great assets to The Company!This project is a small thin wrapper to edit save files for theLethal Companyvideo game.Our documentation can be foundhere.Example usageAdd 6000 credits and unlock all possible (found) ship upgrades.importosimportgreat_assetdefmain()->None:# The classmethod here will resolve the full path to the save file and use save number `1`withgreat_asset.SaveFile.resolve_from_file(1)assave:# update credits to 6000save.update_credits(6000)# unlock all items within `great_asset.ShipUnlock` enum.save.unlock_all_ship_upgrades()# normally without the context manager you'd call the `save.write()` method but this is not necessary# as it is called upon exiting the context manager if there are no errorsDisclaimerThis project is not affiliated with Lethal Company,its creatoror affiliates in any way.
Use of this project within public games without players consent is likely going to remove a lot of the fun from the game and is discouraged.
Package: greate
Greate helps you in creating github repos on the go from your command line.
All you have to do is writegreateand it will create a repository with the name of your current directory.You can also customize your repository by using additional argumentsInstallation$pipinstallgit+https://github.com/yashmehrotra/greate.gitUsageusage: greate [-h] [--ssh] [-d DESCRIPTION] [-n NAME] [-r] [-p]

optional arguments:
  -h, --help            show this help message and exit
  --ssh                 Adds the ssh url for git remote. Default: https
  -d DESCRIPTION, --description DESCRIPTION
                        Description for github repo
  -n NAME, --name NAME  Name for the github repo. Default: Current directory name
  -r, --readme          Create README.md for github repo
  -p, --private         Private github repoExamples$greateUsername:foobarPassword:Repositorycreatedsuccessfully# Use ssh as remote url$greate--sshUsername:foobarPassword:Repositorycreatedsuccessfully# Add description$greate-d"My first project"Username:foobarPassword:RepositorycreatedsuccessfullyTODOClean Code
Package: great-expectations-cloud
cloudQuick StartPythonInstallpip install great_expectations_cloudOptional Dependenciespip install 'great_expectations_cloud[sql]'$gx-agent--helpusage: gx-agent [-h] [--log-level LOG_LEVEL] [--skip-log-file SKIP_LOG_FILE] [--log-cfg-file LOG_CFG_FILE] [--version]optional arguments:-h, --help            show this help message and exit--log-level LOG_LEVELLevel of logging to use. Defaults to WARNING.--skip-log-file SKIP_LOG_FILESkip writing debug logs to a file. Defaults to False. Does not affect logging to stdout/stderr.--log-cfg-file LOG_CFG_FILEPath to a logging configuration json file. Supersedes --log-level and --skip-log-file.--version             Show the gx agent version.Set env variablesGX_CLOUD_ACCESS_TOKENGX_CLOUD_ORGANIZATION_IDStart the AgentIf you intend to run the agent against local services (Cloud backend or datasources) run the agent outside of the container.gx-agentDockerBuilding and running the Agent with DockerDev SetupSee alsoCONTRIBUTING.mdInstallpoetrypipx install poetrySet up virtual environment and install dependencies.poetry install --syncActivate your virtual environment.poetry shellSet up precommit hookspre-commit installDeveloper TasksCommon developer tasks are available viainvoke(defined intasks.py)invoke --listto see available tasks.Synchronize DependenciesTo ensure you are using the latest version of the core and development dependencies runpoetry install --sync.
Also available as an invoke task.invoke depsUpdatingpoetry.lockdependenciesThe dependencies installed in our CI and the docker build step are determined by thepoetry.lock file.To update only a specific dependency(such asgreat_expectations) ...poetry update great_expectationsTo resolve and update all dependencies ...poetry lockIn either case, the updatedpoetry.lockfile must be committed and merged to main.Release to PyPI and DockerTo release a new version to PyPI the version must be incremented.
New versions are automatically published to PyPI when merging tomain.invoke version-bumpA new docker tag will also be generated and pushed toDocker Hub.Building and Running the GX Agent ImageTo build the GX Agent Docker image, run the following in the root dir:invoke dockerRunning the GX Agent:invoke docker --runordocker run --env GX_CLOUD_ACCESS_TOKEN="<GX_TOKEN>" --env GX_CLOUD_ORGANIZATION_ID="<GX_ORG_ID>" gx/agentNow go into GX Cloud and issue commands for the GX Agent to run, such as generating an Expectation Suite for a Data Source.Note if you are pushing out a new image update the image tag version incontainerize-agent.yaml. The image will be built and pushed out via GitHub Actions.Example DataThe contents from/examples/agent/datawill be copied to/datafor the docker container.
Package: great-expectations-ethical-ai-expectations
Great Expectations Ethical AI ExpectationsA collection of Expectations to validate for degradation, bias, and related Ethical Data concerns with Great Expectations.What Is Ethical Data / Ethical AI and Why Is It Important?The buzz around ethical AI has been growing louder and louder. Companies are collecting and usingmore data than ever before. And the influence of that data is growing just as fast—with
data powering decisions and actions across every industry.It's critical that the algorithms fueling these decisions and actions are ethical ones. That's where ethical AI comes in. Ethical AI is artificial intelligence that adheres to strict guidelines (or codes of conduct) regarding fundamental values to ensure automated systems respond to situations in an ethical way. For example, analgorithm that determines credit limits shouldn't discriminate against womenby granting them lower limits.How Can Great Expectations Contribute to Ethical AIGreat Expectations facilitates ethical AI by making it faster and easier to turn codes of conduct into actual code that can be quickly applied to data. For example, one common source of bad model performance is degradation in accuracy over time. For example, an Expectation likeexpect_column_label_and_predicted_pair_accuracy_to_be_betweencould be used to guard against model degradation.Author:Great ExpectationsPyPi Link
Package: great-expectations-geospatial-expectations
Great Expectations Geospatial ExpectationsA collection of Expectations to validate Geospatial data with Great Expectations.What Is Geospatial Data?Geospatial data is information that describes objects, events, or phenomena with a location on or near the surface of the earth. It typically combines location information (usually in the form of coordinates) with attribute information (characteristics) and temporal information (denoting time or life span).How Can Great Expectations Contribute to Geospatial Data?Geospatial data is most useful when it can be analyzed, shared, and integrated with other types of business data to build data visualizations. These visualizations, such as maps, graphs, cartograms, etc., show a more complete picture of the objects, events, or phenomena.However, geospatial data is highly prone to error, as it usually involves robust datasets with data gathered from multiple sources in varying formats. This can cause multiple issues down the line. Before the data is used to create interactive maps and visualizations, it needs to be validated.This package contains a number of Expectations to support validation of Geospatial Data.Author:Great ExpectationsPyPi Link
Package: great-expectations-semantic-types-expectations
Great Expectations Semantic Types ExpectationsA collection of Expectations to validate Semantically Typed Data with Great Expectations.What Are Semantic Types?Semantic Types categorize data by the type of information it represents. For example, consider a column with STRING data types. How do you know what the data means? You could be looking at a list of streets, cities, counties, etc. Without background information, it can be hard to know what you're looking at. That's where Semantic Types come in. The entity’s Semantic Type defines how it should be interpreted.Why should we test on Semantic Types?Testing on these Semantic Types allows us to create more explicit, fit-for-purpose tests, unlocking questions likeDoes this column contain US State abbreviations?instead of askingDoes this column contain strings in the set [AL, AL, AR, AZ...]How do you know when data entities are good candidates for Semantic Types testing?Any data that you can tie to a real-world category or reference is ideal for this kind of test, e.g., phone numbers, ZIP codes, countries, coordinates, URLs, email addresses, etc.This package contains a number of Expectations to support validation of Semantically Typed Data.Author:Great ExpectationsPyPi Link
Package: great-scott
great-scottgreat-scottis a tool that can automatically reverse migrations in a Django project, when switching between different GIT branches.Installation•Usage•Removing GIT hooksInstallationgreat-scottcan be installed in 2 easy steps:Install the toolI recommend installing viapipx:pipxinstallgreat-scottAlternatively, having the project's virtual-env activated, you can of course install the tool directly into virtual-env:python-mpipinstallgreat-scottSetup GIT hooksAfter successful installation, while in the GIT-managed project folder and with virtual-env activated, execute:great-scottinstallUsageReversing migrations should simply work when the GIT branch is changed:$gitcheckoutmig-test
Switchedtobranch'main'👀Lookingformigrationstoreverseonmig-test...
⚠️reversingmigrationsforimporter(upto0015)⚠️reversingmigrationsforpermissions(upto0018)⚠️reversingmigrationsforsubscriptions(upto0044)Ihavereversedmigrationsfor3apps!👉 If you use GIT integration in any of the popular IDEs, such as PyCharm or VSCode, don't forget to properly configure the appropriate python environment there so that automatic reversing of migrations is possible.Removing GIT hooksTo remove the GIT hooks, execute the command (while in the project directory and with virtual-env activated):great-scottuninstall
Package: great-sitemap-search
=====SIMPLESEARCH=====Simplesearch provides an easy and really simple way to offer search on your website.it installs a Class that you can use to execute queries and a managment command you can use to update the indext pages based on a sitemap.xmlQuick start-----------1. Add "simplesearch" to your INSTALLED_APPS setting like this::INSTALLED_APPS = (...'simplesearch',)2. edit settings.py file to include the location of the search index.INDEX_DIR = os.path.join(BASE_DIR, 'index')2. run the command ./manage.py update_search_index <the url of the sitemap>3. access the search backen from your views with:from simplesearch import SimpleSiteSearchersearcher = SimpleSiteSearcher()results = searcher.search('a query String')This will return a list like this:[{title:'some tiele',text:'relevant part of the searched text with <b> on the important terms',url:'the url to the page on your site where the text was found'},...]you may then use the list in your templates to display the search results.
Package: great-tool-ops
GTOGreat Tool Ops. Turn your Git Repo into Artifact Registry:Index your artifacts and add enrichmentsRegister artifact versionsPromote artifacts to environmentsAct on new versions and promotions in CISee example repoCheck out the example repo:https://github.com/iterative/gto-exampleread README in it and try it outTo try out the latest version1. Clone this repositorygitclonegit@github.com:iterative/gto.gitcdgto2. Create virtual environment namedvenvpython3-mvenvvenvsourcevenv/bin/activateInstall python librariespipinstall--upgradepipsetuptoolswheel.3. Runbashshowcase.shThis will createdemobranch and tags. Please don't push them back to this repo :)
To continue experimenting, callgto--helpto see functionality and read through demo example.
For this to work, you need to be locally in this repo.
Working with remote repo isn't supported yet.
Package: greco
Greco - Green Code learning game.Learn Green Code in a friendly way!Greco is a very basic typing game where a word in Green Code is
displayed and then you need to type in using your keyboard.Consistently accurate typing will result in gaining a level and being
rewarded with a silly catchphrase.Green code is a whimsical language so start slowly, don’t take it
seriously and don’t forget to have fun!Requires PyGame to be installed (normal PyGame or pygame_sdl2, either
will work).To learn more about Green Code, please visithttp://ledui.github.io/
Package: grecx
GRecXAn Efficient and Unified Benchmark for GNN-based Recommendation.Homepage and DocumentationHomepage:https://github.com/maenzhier/GRecXPaper:GRecX: An Efficient and Unified Benchmark for GNN-based RecommendationExample Benchmark: Performance on Yelp and Gowalla with BPR LossPerformance on Yelp with BPR Loss:Performance on Gowalla with BPR Loss:DemoWe recommend you get started with some demos.Matrix Factorization (MF)MLP + MFNGCFLightGCNUltraGCNPreliminary ComparisonLightGCN-Yelp dataset (featureless)BCE-lossAlgoPrecision@10Precision@20Recall@10Recall@20nDCG@10nDCG@20MF0.0295970.0254950.0327330.0560860.0373320.045805NGCF0.0247130.0218930.0282510.0496110.0313570.039549LightGCN————0.0373500.045872UltraGCN-single0.0306520.0267900.0339130.0588860.0385760.047766UltraGCN0.035530.0303460.0395260.0670280.0453650.055376BPR-lossAlgoPrecision@10Precision@20Recall@10Recall@20nDCG@10nDCG@20MF0.0314890.0273030.0347330.0603330.0401030.049406NGCF0.0303750.0266990.0345020.0599840.0387320.048351LightGCN0.0335440.0289960.0372770.0641280.0429070.052667UltraGCN-single——————UltraGCN——————Note that “UltraGCN-single” uses loss with one negative sample and one negatvie loss weightCiteIf you use GRecX in a scientific publication, we would appreciate citations to the following paper:@misc{cai2021grecx,
title={GRecX: An Efficient and Unified Benchmark for GNN-based Recommendation},
author={Desheng Cai and Jun Hu and Shengsheng Qian and Quan Fang and Quan Zhao and Changsheng Xu},
year={2021},
eprint={2111.10342},
archivePrefix={arXiv},
primaryClass={cs.IR}
}
Package: grecy
greCyAncient Greek models for spaCygreCy is a set of spaCy ancient Greek models and its installer. The models were trained using thePerseusandProiel UDcorpora.InstallationFirst install the python package as usual:pipinstall-UgrecyOnce the package is successfully installed, you can proceed to install any of the followings models:grc_perseus_smgrc_proiel_smgrc_perseus_lggrc_proiel_lggrc_perseus_trfgrc_proiel_trfThe models can be installed from the terminal with the commands below:python -m grecy install MODELwhere you replace MODEL by any of the model names listed above.  The suffixes after the corpus name _sm, _lg, and _trf indicate the size of the model, which directly depends on the word embeddings used to train the models. The smallest models end in _sm (small) and are the less accurate ones: they are good for testing and building lightweight apps. The _lg and _trf are the large and transformer models which are more accurate. The _lg were trained using floret word vectors, and the _trf models use a special version of BERT that was pretrained with the largest Ancient Greek corpus available in the web.LoadingAs usual, you can load any of the six models with the following Python lines:import spacy
nlp = spacy.load("grc_proiel_XX")Remember to replace  _XX  with the size of the model you would like to use, this means, _sm for small, _lg for large, and _trf for transformer. The _trf model is the most accurate but also the slowest.UsespaCy is a powerful NLP library with many applications. The most basic of its function is the morpho-syntantic annotation of texts for further processing. A common routine is to load a model, create a doc object, and process a text:import spacy
nlp = spacy.load("grc_proiel_trf")

text = "καὶ πρὶν μὲν ἐν κακοῖσι κειμένην ὅμως ἐλπίς μʼ ἀεὶ προσῆγε σωθέντος τέκνου ἀλκήν τινʼ εὑρεῖν κἀπικούρησιν δόμον"

doc = nlp(text)

for token in doc:
    print(f'{token.text}, lemma: {token.lemma_} pos:{token.pos_}')The apostrophe issueUnfortunately, there is no consensus how to represent the Ancient Greek apostrophe. Modern Greek simply uses the regular apostrophe, but ancient texts available in Perseus and Perseus under Philologic use various unicode characters for the apostrophe. Instead of the apostrophe, we find the 'Greek koronis', 'modifier letter apostrophe', and 'right single quotation mark.' Provisionally, I have opted to use 'modifier letter apostrophe' in the corpora with which I trained the models. This means that, if you want the greCy models to properly handle the apostrophe, you have to make sure that the Ancient Greek texts that you are processing use the modifier letter apostropheʼ(U+02BC ). Otherwise the models will fail to lemmatize and tag some words in your texts that ends with an 'apostrophe'.
Package: gredis
gredisgRedis is an asynchronous client library of Redis written withTornadocoroutine.gRedis is standing on the shoulders of giants:redis-pyTornadoInstallationpipinstallgredisOReasy_installgredisORgitclonehttps://github.com/coldnight/grediscdgredispythonsetup.pyinstallUsagefromtornadoimportgenfromtornadoimportwebfromgredis.clientimportAsyncRedisclient=AsyncRedis("ip.or.host",6379)classDemoHandler(web.RequestHandler):@gen.coroutinedefget(self):ret=yieldclient.incr("key")redis=client.to_blocking_client()ret2=redis.incr("key")self.write(str(ret+ret2))Pub/Subfromtornadoimportgenfromtornadoimportwebfromgredis.clientimportAsyncRedisclient=AsyncRedis("ip.or.host",6379)classPubSubHandler(web.RequestHandler):@gen.coroutinedefget(self):pubsub=client.pubsub()channel="test"yieldpubsub.subscribe(channel)response=yieldpubsub.get_message(True)assertresponse["type"]=="subscribe"response=yieldpubsub.get_message(True)assertresponse["type"]=="message"self.write(response['data'])@gen.coroutinedefpost(self):yieldclient.publish(channel,"test")Not Implementationpipeline
Package: gredisql
GredisQLA GraphQL interface for Redis Database.How To InstallpipinstallgredisqlIf you find this project interesting, you can always appreciate it by giving it a Star. :DA Background ofGredisQLMotivationI was bored, been sick for a while, had to lie on the bed. So I needed to create something.Redis has Web interface ( actually a REST interface), so I urged to build one in GraphQL.There are some pretty amazing GraphQL libraries around python echo system, I wanted to try them.Last but not least, jump into quick coding session, engage and nurture the human mind. LOLDesign PhilosophyAll the datamutationandqueryare not separated here by action and most probably all the actions are performed viaqueryoperation.Technicallyallthe requests sent to the GraphQLserverwas inPOST, so I was initially okay with the implementation.Strawberry-Graphqlis kind of server agnostic so either you can useASGIorWSGIcounterpart.Currently limiting the implementation withWSGIserver, but I've plan to adoptASGIin the journey, to supportsubscription.NotallRedis commands are found in the implementation, I'll try to cover it in the process.Inspiration and Tools I usedredis==5.0.0is used to communicate with the Redis database.strawberry-graphqlis used to do the heavy lifting. Also, I triedariadnewhich is also another cool tool to try with.Features and Future PlansString Commands.List Commands.Set Commands.And many more to come in the future iteration.Quick Starting the GraphQL Serverif__name__=="__main__":fromgredisql.coreimportServerserver=Server()server.run()You can specify thehost,portanddebugmode in while instantiating theGraphQLserver.
Simply write,if__name__=="__main__":REDIS_HOST='redis-4343.c8.us-east-1-4.ec2.cloud.redislabs.com'REDIS_PORT=16292REDIS_PASSWORD='your-secret-password'fromgredisql.coreimportServerserver=Server(REDIS_HOST=REDIS_HOST,REDIS_PORT=REDIS_PORT,REDIS_PASSWORD=REDIS_PASSWORD)server.run()Now navigate tohttp://localhost:5055/graphqland voilà.
Package: greece
GREECE (Geographic REnewable Energy Candidate Extraction) modelGREECE is a pre-processing model used to extract geographical candidate sites for further selection of optimal RE sites (location and size) using combinatorial optimization.IntroductionGREECE processes various geographic layers (areas, networks, terrain, resource) with respect to various range control parameters (buffer, threshold, surface area).
It is composed of several sub-models, at the moment for solar GHI synthetic generation, PV conversion, or else road transportation.
The model is written in Python and the interface is made through configuration files and Shell scripts.InstallationThe easiest way to install greece is through Pypi. In your preferred virtual environment, just type in:$ pip install greeceTODOHere's the list of what is done and what remains to be done:Constraint modelSolar GHI modelPV conversion modelBiomass modelHydro modelWind modelStorage modelTerrain-based effects on solar radiation (horizon obstruction + altitude)PostgreSQL interface for input dataPower Flow model for further analysis of network voltage stabilityLink to CPLEX optimization within Python (throughcplexorpyomo)How to useFirst, add "/greece/rentools/shell_scripts" directory to your global path (using ~/.bashrc or ~/.profile files).
Make all python scripts executable, e.g.:$ sudo chmod +x solar_ghi.pyThen, build configuration directory ("greece_%s_config" with %s={'solar', 'pv', 'biomass'}) for your problem such as:$ build_config.py --type solar /path/to/dir/where/config/must/be/storedFill corresponding config files. Finally, you can call the script corresponding to the model you want to run. Typical usage is:$ solar_ghi.py path/to/corresponding/config/folder