Saravanan666/pypi-org huggingface dataset:
Package: gros-client-car
傅利叶Car-客户端SDK（python）概述本例(GROS_Client_Car SDK)适用于您已经拥有傅利叶（Fourier）所提供的Car设备，通过本例可实现对机器人的控制。它提供了一组简单的API，让你可以轻松地进行交互。快速上手安装pipinstallgros_client_car导入sdk首先你需要在你的Python代码中导入这个SDKfromgros_client_carimportCar创建Car对象然后，你需要创建一个Car对象，以便使用这个SDKfromgros_client_carimportCar# 按需导入Human、同理还有Car、Dog等car=Car(host='192.168.9.17')示例代码下面是一个完整的示例代码，演示如何使用这个SDK来控制机器人：fromgros_client_carimportCar# 引入依赖fromgros_client_carimportCar,Mod# 实例化human对象car=Car(host='192.168.9.17')# 调用启动方法car.start()# 切换四轮模式car.set_mode(Mod.MOD_4_WHEEL)# 以速度10向正前方移动car.move(-10,0)# 以速度20向正后方移动car.move(20,0)# 以速度20向右(30度)后方移动car.move(20,30)
Package: grote
GroTE: Groningen Translation Environment 🐮Accessing the GroTE demoAn online GroTE demo is available athttps://grote-app.hf.space. The demo will log events to the private repositorygrote/grote-logs.Running GroTE locallyInstall requirements:pip install -r requirements.txt.Make sure you have a localnpminstallation available to run the front-end.Rungrotein your command line to start the server.Visithttp://127.0.0.1:7860to access the demo. By default, logs are written to the locallogsdirectory, which is synchronized with the repositorygrote/grote-logs.TODOsMove loading togradio_modalEnable restoring the previous state of edited sentences for a known file if previous edits were logged.Enable local logging if no remote logging is available.
Package: grott-ha-plugin
grott-ha-pluginPlugin to interface Home Assistant and Grott. Allow auto discovery of the devices on Home Assistant.Compatibility:Python:3.83.93.103.11Grott:2.7.X2.8.XThis plugin is tested on linux (and best effort support for macOS and Windows)Installationpipinstallgrott-ha-pluginUsageOnce installed you need to add the plugin to the Grott configuration file,grott.ini, here an example:[extension]extension=Trueextname=grottext.haextvar={"ha_mqtt_host": "192.168.20.2", "ha_mqtt_port": "1883", "ha_mqtt_user": "XXXXX", "ha_mqtt_password": "XXXX"}ConfigurationThe extension name (extname) isgrottext.haThe extension variable (extvar) is a json string with the following keys:ha_mqtt_host: the mqtt host of the server used by Home Assistantha_mqtt_port: the mqtt port of the server used by Home Assistantha_mqtt_user: the mqtt userha_mqtt_password: the mqtt passwordHome assistant configurationOn home assistant you need to have the MQTT integration enabled
(docs:https://www.home-assistant.io/integrations/mqtt/) and configured.You also need a MQTT broker, the recommended one is the mosquitto add-on you can install from the add-on store.The MQTT broker needs to have a user to allow Grott to connect to it.
(This can be configured in the mosquitto add-on configuration page if you are using it)Home assistant add-onThere is a pre-packaged add-on existing for Home Assistant running in Home Assistant Operating System (HAOS).If you use the mosquitto add-on, the addon will automatically configure Grott and the plugin to use the mosquitto broker.
It's a lot easier.The add-on is available at:egguy HA addons - stable: The stable version (recommended)egguy HA addons - beta: The beta version (includes the latest changes in testing)egguy HA addons - edge: The edge version (includes the latest changes -Not recommended for day-to-day usage)
Package: grou
Currently grou output the release note info from git merge log.
Othre git log info like “commitizen” style are not supported for now.
Home-page:https://github.com/gki/grouAuthor: Gen Takeda
Author-email:gki.penguin@gmail.comLicense: MIT
Description: UNKNOWN
Keywords: git merges log formatted pretty release note output
Platform: UNKNOWN
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3.6
Package: groufi
Group feature importanceThis release looks at the role of joint feature importance for explainability in instances where
features may be highly correlated when providing an output. Specifically, the method operates by
regrouping the correlated features and then looking at the group-level impact of imputation. Doing
so allows us to consider the impact of a joint permutation of the correlated features.ExamplesSome examples are available inexamplesInstallationInstalling withpipThis repository is tested on Python 3.9, and Linux systems.
It is recommended to install in a virtual environment to keep your system in order.
The following command installs the latest version of the library:pipinstallgroufiInstalling from sourceTo installgroufifrom source, you can follow the steps below. First, you will need to
installpoetry.poetryis used to manage and install
the dependencies.
Ifpoetryis already installed on your machine, you can skip this step. There are several ways to
installpoetryso
you can use the one that you prefer. You can check thepoetryinstallation by running the
following command:poetry--versionThen, you can clone the git repository:gitclonegit@github.com:BorealisAI/group-feature-importance.gitThen, it is recommended to create a Python 3.8+ virtual environment. This step is optional so you
can skip it. To create
a virtual environment, you can use the following command:makecondaIt automatically creates a conda virtual environment. When the virtual environment is created, you
can activate it with
the following command:condaactivategroufiThis example usescondato create a virtual environment, but you can use other tools or
configurations. Then, you
should install the required package to usegroufiwith the following command:makeinstallThis command will install all the required packages. You can also use this command to update the
required packages. This
command will check if there is a more recent package available and will install it. Finally, you can
test the
installation with the following command:maketestLicenseThis repository is released under the Attribution-NonCommercial-ShareAlike 4.0 International license
as found in
theLICENSEfile.
Package: ground
groundSummarygroundis a pure Python library that provides protocols
for planar computational geometry models & operations
to unify interaction between different libraries
and allow customization.In what followspythonis an alias forpython3.7orpypy3.7or any later version (python3.8,pypy3.8and so on).InstallationInstall the latestpip&setuptoolspackages versionspython-mpipinstall--upgradepipsetuptoolsUserDownload and install the latest stable version fromPyPIrepositorypython-mpipinstall--upgradegroundDeveloperDownload the latest version fromGitHubrepositorygitclonehttps://github.com/lycantropos/ground.gitcdgroundInstall dependenciespython-mpipinstall-rrequirements.txtInstallpythonsetup.pyinstallUsage>>>fromground.baseimportget_context>>>context=get_context()>>>Multipoint=context.multipoint_cls>>>Point=context.point_cls>>>Segment=context.segment_cls>>>origin=Point(0,0)>>>x_unit=Point(1,0)>>>y_unit=Point(0,1)>>>fromground.baseimportKind>>>context.angle_kind(origin,x_unit,y_unit)isKind.RIGHTTrue>>>fromground.baseimportOrientation>>>(context.angle_orientation(origin,x_unit,y_unit)...isOrientation.COUNTERCLOCKWISE)True>>>context.cross_product(origin,x_unit,origin,y_unit)==1True>>>context.dot_product(origin,x_unit,origin,y_unit)==0True>>>context.multipoint_centroid(Multipoint([origin]))==originTrue>>>(context.points_convex_hull([origin,x_unit,y_unit])...==[origin,x_unit,y_unit])True>>>context.segment_contains_point(Segment(origin,x_unit),y_unit)False>>>context.segment_contains_point(Segment(origin,x_unit),origin)True>>>context.segments_intersection(Segment(origin,x_unit),...Segment(origin,y_unit))==originTrue>>>fromground.baseimportRelation>>>context.segments_relation(Segment(origin,x_unit),...Segment(origin,y_unit))isRelation.TOUCHTrueDevelopmentBumping versionPreparationInstallbump2version.Pre-releaseChoose which version number category to bump followingsemver
specification.Test bumping versionbump2version--dry-run--verbose$CATEGORYwhere$CATEGORYis the target version number category name, possible
values arepatch/minor/major.Bump versionbump2version--verbose$CATEGORYThis will set version tomajor.minor.patch-alpha.ReleaseTest bumping versionbump2version--dry-run--verbosereleaseBump versionbump2version--verbosereleaseThis will set version tomajor.minor.patch.Running testsInstall dependenciespython-mpipinstall-rrequirements-tests.txtPlainpytestInsideDockercontainer:withCPythondocker-compose--filedocker-compose.cpython.ymlupwithPyPydocker-compose--filedocker-compose.pypy.ymlupBashscript:withCPython./run-tests.shor./run-tests.shcpythonwithPyPy./run-tests.shpypyPowerShellscript:withCPython.\run-tests.ps1or.\run-tests.ps1cpythonwithPyPy.\run-tests.ps1pypy
Package: grounder
Grounder[](https://pypi.org/project/grounder/)
[](https://pypi.python.org/pypi/grounder/)Estimate the quality and factual correctness of natural language text to help ground language models such as BERT, GPT-J, GPT-Neo, ChatGPT, and Bard.QuickstartIf you have install python packages from source before, you will probably be able to follow these steps to get going quickly:pipinstall--upgradepipvirtualenvpoetry
mkdir-p~/code/tangibleaicd~/code/tangibleai
gitclonegit@gitlab.com:tangbileai/community/groundercdgrounder
python-mvirtualenv.venvsource.venv/bin/activate||source.venv/Scripts/activate
pipinstall--editable.
Package: groundlight
Groundlight Python SDKGroundlight makes it simple to build reliable visual applications. Read thefull documentation here.Computer Vision powered by Natural LanguagepipinstallgroundlightBuild a working computer vision system in just a few lines of python:fromgroundlightimportGroundlightgl=Groundlight()det=gl.get_or_create_detector(name="doorway",query="Is the doorway open?")img="./docs/static/img/doorway.jpg"# Image can be a file or a Python objectimage_query=gl.submit_image_query(detector=det,image=img)print(f"The answer is{image_query.result}")How does it work?Your images are first analyzed by machine learning (ML) models which are automatically trained on your data. If those models have high enough confidence, that's your answer. But if the models are unsure, then the images are progressively escalated to more resource-intensive analysis methods up to real-time human review. So what you get is a computer vision system that starts working right away without even needing to first gather and label a dataset. At first it will operate with high latency, because people need to review the image queries. But over time, the ML systems will learn and improve so queries come back faster with higher confidence.Note: The SDK is currently in "beta" phase. Interfaces are subject to change in future versions. We will followsemversemantics for breaking changes.Learn moreSome more resources you might like:Code DocumentationPython SDK on PyPiorGitHubCompanyLogin to Groundlight App
Package: groundstation
groundstation=============groundstation is a decentralised task/project management suite.It's uses are wide and varied, but some key examples are:* Locale driven marketplaces.* Fully decentralised bulletin boards.* Networks that keep working long after the internet has failed.The core of its implementation is an object store of linked immutable objectsthat are synced via a gossip protocol.The current version uses libgit2 as a storage backend, but doesn't use many gitprimitives, beyond git's objects as a storage medium. Git is deliberatelypulled out into a storage driver, however while groundstation doesn't assumethat you're using git it does assume you're using something that looks *a lotlike git*.pygit2------groundstation uses pygit2 under the hood for its git interactions, and somefeatures that it depends on have not landed in a stable release yet.For this reason, you'll need to build and install the latest [libgit2][1] fromsource.protocol support----------------groundstation hinges on the notion of protocols internally- groundstation coreprovides you with content addressable storage, but it's up to you to work outwhat to actually do with that data.That said, groundstation does ship with some protocol adaptors. Adaptors takethe form `name@domain:adaptor-version`, and until such time as a release isalready, everything that ships with groundstation will be released with`richo@psych0tik.net` as the email, ie `richo@psych0tik.net:github-0.0.0`.development-----------groundstation uses [babashka][3] for managing its dependencies. If you have it installed, you should be able to do something like:`babashka groundstation_dev` and wind up with a working environment. Maybe.1. install libgit2 v0.18.02. `pip install -r requirements.txt`3. ???????4. profit!You probably want to install those requirements in a virtualenv.You'll almost certainly want to have a read of the [hacking document](HACKING.md),and checkout the other [misc hacking docs](HACKING/).[1]:http://libgit2.github.com/[2]:https://github.com/libgit2/pygit2#building-on-nix-including-os-x[3]:https://github.com/richo/babashka
Package: groundwork
groundwork is a Python based microframework for highly reusable applications and their components.Its functionality is based on exchangeable, documented and tested plugins and patterns.It is designed to support any kind of Python application: command line scripts, desktop programs or web applications.groundwork enables applications to activate and deactivate plugins during runtime and to control dynamic plugin
behaviors like plugin status, used signals, registered commands and much more.The functionality of plugins can easily be extended by the usage of inheritable patterns.
Thus, groundwork supports developers with time-saving solutions for:Command line interfacesLoose inter-plugin communication via signals and receiversShared objects to provide and request content to and from other pluginsStatic and dynamic documents for an overall documentationExampleThe following code defines a plugin with command line support and creates a groundwork application which activates
the plugin:from groundwork import App
from groundwork.patterns import GwCommandsPattern

class MyPlugin(GwCommandsPattern):
    def _init_(self, *args, **kwargs):
        self.name = "My Plugin"
        super().__init__(*args, **kwargs)

    def activate(self):
        self.commands.register(command='hello',
                               description='prints "hello world"',
                               function=self.greetings)

    def greetings(self):
        print("Hello world")

if __name__ == "__main__":
    my_app = App(plugins=[MyPlugin])        # Creates app and registers MyPlugin
    my_app.plugins.activate(["My Plugin"])  # Initialise and activates 'My Plugin'
    my_app.commands.start_cli()             # Starts the command line interfaceThe following commands can be used on a command line now:python my_app.py hello      # Prints 'Hello world'
python my_app.py            # Prints a list of available commands
python my_app.yp hello -h   # Prints syntax help for the hello command
Package: groundwork-sphinx-theme
This repository contains sphinx styles, which are use by most groundwork related projects.
It is a derivative of Kenneth Reitz’s themes for his projects and of Mitsuhiko’s themes for Flask and Flask related
projects.  To use this style in your Sphinx documentation, follow this guide:Install the package using pip:pip installgroundwork-sphinx-themeAdd this toconf.py:html_theme='groundwork'ConfigurationThe groundwork-sphinx-theme provides the following configuration parameters:sidebar_width: Allows the user to set the sidebar width in pixels. Good for deeply nested TOCs (Default: 220x)stickysidbar: If True it makes the sidebar always visible if pages get longer (Default: True)stickysidbarscrollable: Makes the sticky sidebar scrollable in small browser windows (Default: False)contribute: If True, a contribute-area with github-buttons is shown inside the sidebargithub_user: Used the for github follow button. E.g.: useblocksgithub_fork: Used for the github fork buttons. E.g.: useblocks/groundworkYou can change their value inside the fileconf.pyof your sphinx project:html_theme_options = {
    "sidebar_width": '240px',
    "stickysidebar": True,
    "stickysidebarscrollable": True,
    "contribute": True,
    "github_fork": "useblocks/groundwork",
    "github_user": "useblocks",
}Screenshot
Package: groundwork-spreadsheets
Groundwork patterns to read and write spreadsheet documents. Excel 2010 (xlsx, xlsm) is supported at the moment.
The full documentation is available athttps://groundwork-spreadsheets.readthedocs.io/For more information regarding groundwork, seehere.ExcelValidationPatternUses the libraryopenpyxlCan read Excel 2010 files (xlsx, xlsm)Configure your sheet using a json fileAuto detect columns by namesLayout can becolumn based: headers are in a singlerowand data is belowrow based: headers are in a singlecolumnand data is right of the headersDefine column types and verify cell values against themDateEnums (e.g. only  the values ‘yes’ and ‘no’ are allowed)Floating point numbers with optional min/max checkInteger numbers with optional min/max checkString with optional regular expression pattern checkExclude data row/columns based on filter criteriaOutput is a dictionary of the following formrow or column number->header name->cell valueExtensive logging of problemsHere is how an example json config file looks like:{
    "sheet_config": "last",
    "orientation": "column_based",
    "headers_index_config": {
        "row_index": {
            "first": 1,
            "last": "automatic"
        },
        "column_index": {
            "first": "automatic",
            "last": "severalEmptyCells:3"
        }
    },
    "data_index_config": {
        "row_index": {
            "first": 2,
            "last": "automatic"
        },
        "column_index": {
            "first": "automatic",
            "last": "automatic"
        }
    },
    "data_type_config": [
        {
            "header": "hex number",
            "fail_on_type_error": true,
            "fail_on_empty_cell": false,
            "fail_on_header_not_found": true,
            "type": {
                "base": "string",
                "pattern": "^0x[A-F0-9]{6}$"
            }
        },
        {
            "header": "int number",
            "type": {
                "base": "integer",
                "minimum": 2
            }
        }
    ]
}
Package: group10pack
DSCI-310-Group-10-PackageDSCI-310-Group-10-Package is a Python package for the investment income outcome analysis done for DSCI310. This package is largely dependent on the scikit-learn and matplotlib packages, and is distributed under the MIT License.The functions in this package have roles related to hyperparamater optimizations for specific machine learning models, and plot the results obtained.The main project where this package is used can be found in the following GitHub Repository:https://github.com/DSCI-310/DSCI-310-Group-10Installation$pipinstallgroup10packUsageClick on the following link for a short tutorial on how to use the functions in this package.exampleContributingInterested in contributing? Check out the contributing guidelines. Please note that this project is released with a Code of Conduct. By contributing to this project, you agree to abide by its terms.LicenseDSCI-310-Group-10-Packagewas created by Harry Zhang Ahmed Rizk Mahdi Heydar Nikko Dumrique. It is licensed under the terms of the MIT license.CreditsDSCI-310-Group-10-Packagewas created withcookiecutterand thepy-pkgs-cookiecuttertemplate.LicenseThis project is licensed under the MIT License andCreative Commons Attribution-NonCommerical-NoDerivatives 4.0 International License
Package: group4package
group4packageA package for running Group 4's data analysisInstallationNote: This package requires python version 3.9.1 or greater$pipinstallgroup4packageUsageThe following functions in this package were created for Group 4's ProjectPredicting Defaults of Credit Card Clients.
However, they are useful for any data analysis that involves pre-processing data and calculating classification metrics and statistics.calculate_metrics(FP, TN, TP)calulates Recall, F1-Score and Precision for a classification modelExample:fromgroup4packageimportmetrics_functionascmTN,FP,FN,TP=confusion_matrix(y_test,predict).ravel()res=cm.calculate_metrics(FP,FN,TP)get_summary_stats(df)calculates summary statistics including mean, std, min, and max of numeric columns of a dataframeExample:fromgroup4packageimportsummary_stats_functionasssss.get_summary_stats(train_df)count_plot(df, x, name)creates a plot of the counts between x and y values of the given dataframe, while the latter two arguments are used as the x-axis label and title of the produced plotExample:fromgroup4package.function_count_plotimportcount_plotnew_plot=count_plot(df=train_df,x="x-axis label",name="Plot Title")pre-process data(df, train_frac, seed)drops all rows with missing or null values and then splits the dataframe into training and testing sets according to the given split ratioExample:fromgroup4packageimportpreprocessaspptrain_df,test_df=pp.preprocess(df,0.8,200)ContributingInterested in contributing? Check out the contributing guidelines. Please note that this project is released with a Code of Conduct. By contributing to this project, you agree to abide by its terms.Licensegroup4packagewas created by Hannah, Jordan, Diana, and Shravan. It is licensed under the terms of the MIT license.Creditsgroup4packagewas created withcookiecutterand thepy-pkgs-cookiecuttertemplate.
Package: group-based-policy
Group Based Policy (GBP) provides declarative abstractions for achieving
scalable intent-based infrastructure automation.GBP complements the OpenStack networking model with the notion of policies
that can be applied between groups of network endpoints. As users look beyond
basic connectivity, richer network services with diverse implementations and
network properties are naturally expressed as policies. Examples include
service chaining, QoS, path properties, access control, etc.GBP allows application administrators to express their networking requirements
using a Group and a Policy Rules-Set abstraction. The specifics of policy
rendering are left to the underlying pluggable policy driver.GBP model also supports a redirect operation that makes it easy to abstract
and consume complex network service chains and graphs.Checkout the GBP wiki page for more detailed information:
<http://wiki.openstack.org/GroupBasedPolicy>The latest code is available at:
<http://git.openstack.org/cgit/openstack/group-based-policy>.GBP project management (blueprints, bugs) is done via Launchpad:
<http://launchpad.net/group-based-policy>For help using or hacking on GBP, you can send mail to
<mailto:openstack-dev@lists.openstack.org>.Acronyms used in code for brevity:PT:  Policy Target
PTG: Policy Target Group
PR:  Policy Rule
PRS: Policy Rule Set
L2P: L2 Policy
L3P: L3 Policy
NSP: Network Service Policy
Package: group-B-audio-analyzer
Audio analysis
The customer request is to create a tool to denoise audio tracks and
classify them into three classes: human voices, musical instruments, and
others.To denoise the audio you should not use any ML algorithm but you are
suggested to adopt a specific Wiener filter..To classify the audio tracks you can perform the audio analysis in the
Fourier Domain (applying FFT to the original signal).Use visualisation to show the differences among the three classes of audio
tracks.Once finished with this task, you can compare this classification with the
one obtainable with a Convolution Neural Network (CNN) applied to the
images obtained from padding the audio tracks. (For this step you can take
advantage of PyTorch or Keras).The data
To structure and test the first class of your audio data analysis
pipeline, the denoiser, a possibility is to use the clean subset of audio
tracks in the Freesound mono audio track dataset, DBR-dataset, first
adding white random noise to each track, and then, trying to remove the
white noise from the signal.Using the same dataset you can also test your classifier.Once you have tested the audio analysis pipeline on this dataset, create a
small data set yourself, recording similar audio tracks and paying
attention to the standardization of the input data.Useful tools
To convert the audio tracks into signals treatable with Scipy you can use
the PyAudio library.To construct the Wiener filter you can use the Scipy and Numpy libraries.