Saravanan666/pypi-org huggingface dataset:
Package: gordo
GordoBuilding thousands of models with timeseries data to monitor systems.AboutGordo fulfills the role of inhaling config files and supplying components to the pipeline of:Fetching dataTraining modelServing modelComponentsgordo-controller- Kubernetes controller for the Gordo CRDs.gordo-core- Gordo core library.gordo-client- Gordo server's client. It can make predictions from deployed models.Documentation is available on Read the DocsInstallgordo-helm- you can usegordohelm chart from this repository to deploy gordo infrastructure to your Kubernetes cluster.Python packagepip install --upgrade gordoWith additional extras:pip install gordo[postgres,mlflow]Bleeding edge:pip install git+https://github.com/equinor/gordo.gitDeveloper manualThis section will explain how to start development of Gordo.SetupCreate and activate a virtual environment first. As a default option, it can bevenvmodule.Install pip-toolspip install --upgrade pip
pip install --upgrade pip-toolsInstall requirementspip install -r requirements/full_requirements.txt
pip install -r requirements/test_requirements.txtInstall package:python3 setup.py installHow to update packagesNote: you have to installpip-toolsversion higher then6for requirements to have same multi-line output format.To update some package infull_requirements.txt:Change its version inrequirements.infile;Compile and upgrade requirements:pip-compile--upgrade--output-file=full_requirements.txtmlflow_requirements.inpostgres_requirements.inrequirements.inExamplesSee ourexamplenotebooks for how to develop withgordolocally.How to run tests locallyList of commands to run tests can be foundhere.
Running of tests takes some time, so it's faster to run tests in parallel:pytest -n auto -m 'not dockertest' --ignore benchmarksRun docker-related tests:pytest -m 'dockertest'NOTE:To run tests it's required for your system to has (note: commands might differ from your OS):Running docker daemon.Available 5432 port forpostgrescontainer.NOTE:this example is for Pycharm IDE to usebreakpointsin the code of the tests.On the configuration setup for test running add toAdditional arguments:inpytestsection following string:--ignore benchmarks --cov-report= --no-covBuild the documentationThis command will run the local documentation server:> cd docs/> make watch
Package: gordo-client
Gordo clientClient forGordoproject.Documentation is available on Read the DocsInstallationAt least python 3.9 need to be installed in the system first.In order to install or uninstall this library run following commands.# Installpipinstallgordo-client# Uninstallpipuninstallgordo-clientDevelopers InstructionsSetupInstallpoetry.Setup and run development shell instance:> poetry install> poetry shellYou could also install and applypre-commithooks.Runpoetry installto install or re-install all dependencies.Runpoetry updateto update the locked dependencies to the most recent
version, honoring the constrains put insidepyproject.toml.Pre-commitYou could also install and applypre-commithooks.Run testsInstalldocker(or similar container manager) if you want to run test-suite.Run tests (except docker-related ones):> poetry run pytest -n auto -m "not dockertest"Run docker-related tests:> poetry run pytest -m "dockertest"
Package: gordo-core
Gordo core library.The main component can be foundhere.Documentation is available on Read the DocsInstallationAt least python 3.10 need to be installed in the system first.pip3 install gordo-coreDevelopers InstructionsSetupInstallpoetry.Setup and run development shell instance:> poetry install> poetry shellPre-commitYou could also install and applypre-commithooks.Run testsInstalldocker(or similar container manager) if you want to run test-suite.Run tests (except docker-related ones):> poetry run pytest -n auto -m "not dockertest"Run docker-related tests:> poetry run pytest -m "dockertest"Build documentation:> cd docs/> poetry run make watch
Package: gordo-dataset
Gordo datasetgordo dataset library essential to build datasets and data providers forgordoprojects.UsageData providerExtendGordoBaseDataProviderto adapt it to your data source.See examplesNcsReaderthat reads either parquet or csv files from Azure Datalake v1.DatasetExtendGordoBaseDataset.See example forTimeSeriesDatasetthat arranges the data into consecutive times series.Installpip install gordo-datasetUninstallpip uninstall gordo-datset
Package: gorealtime
# gorealtime-python## Quickstart```pythonimport gorealtimeclient = gorealtime.Client('app_key', 'app_secret')client.push('Example message', ['channel1', 'second_channel'])```## InstallationInstallation is done using `pip``$ pip install gorealtime`If you want the latest possible version, grab it directly from the git repo.However, be careful as this *may be broken*.`$ pip install git+https://github.com/gorealtime/gorealtime-python.git`# Links- [Docs](http://gorealtime-python.readthedocs.org/en/latest/)- [Issues](https://github.com/gorealtime/gorealtime-python/issues)
Package: gorella
# GoRella
[![Build Status](https://travis-ci.org/frostming/gorella.svg?branch=master)](https://travis-ci.org/frostming/gorella)Monkey patch regular expression methods to built-in string types## Introduction
This project is aiming at easing the use of regular expression,
which is inspired byRegExpin JavaScript. The name comes from “gorilla” and “re”. The sing-file module will monkey patch the following built-in methods of string types on its import:replacesplitandrsplitfindandrfindindexandrindexpartitionandrpartitioncountstartswithandendswithBesides, it extends the built-in string types with following methods ofremodule:matchsearchfindallfinditer## Usage
All you need is to import gorella in one line, everything is done for you:`python >>> import gorella >>> 'I am 26 yearsold.'.search('\d+').group()'26' `For built-in methods, when pass a regular expression object, it will call the corresponding re function, else it falls back to built-in one:`python >>> pat =re.compile('\d+')>>> 'I am 26 yearsold.'.find('am')2 >>> 'I am 26 yearsold.'.find(pat)5 >>> 'I am 26 yearsold.'.partition(pat)('I am ', '26', ' years old') `Because it replaces the pure-C methods with python ones, the performance may be affected.## Python 3 support
The monkey patching highly depends on the C-API of CPython, so it doesn’t support other implementations than CPython. The test passes on Python 2.6, 2.7, 3.3, 3.4 and 3.5## License
MIT
Package: gorep
gorep - Gor Grep Middleware.Gor Middleware, 过滤掉不符合 PATTERN 的 Request/Response。安装pipinstallgorep使用$gorep--help

Usage:gorep[OPTIONS]PATTERN仅输出匹配PATTERN的消息。默认情况下搜索Request和Response。如果需要仅搜索其中一个，则需要明确指定（-Q,-S）。默认情况下搜素HTTPHeaders和Body字段。如果需要搜索其他字段，则需要明确指定，比如-mphb表示搜索Method,Path,Headers,Body。典型用法：gor--input-raw-track-response--input-raw:80--output-stdout--middleware"gorep something"Options:-Q,--request搜索HTTPRequest.-S,--response搜索HTTPResponse.-m,--method搜索HTTPMethod.-p,--path搜索HTTPPath.-v,--version搜索HTTPVersion.-c,--status-code搜索HTTPStatusCode.-t,--status-text搜索HTTPStatusText.-h,--headers搜索HTTPHeaders.-b,--body搜索HTTPBody.--helpShowthismessageandexit.
Package: gorilla
Gorilla is a Python library that provides a convenient approach to monkey
patching.Monkey patching is the process ofmodifying module and class attributes at
runtimewith the purpose of replacing or extending third-party code.Althoughnota recommended practice, it is sometimes useful to fix or modify
the behaviour of a piece of code from a third-party library, or to extend its
public interface while making the additions feel like they are built-in into
the library.The Python language makes monkey patching extremely easy but the advantages of
Gorilla are multiple, not only in assuring aconsistent behaviouron both
Python 2 and Python 3 versions, but also in preventing common source of errors,
and making the process bothintuitive and convenienteven when faced withlargenumbers of patches to create.Featuresintuitive and convenient decorator approach to create patches.can create patches for all class or module members at once.compatible with both Python 2 and Python 3.customizable behaviour.UsageThanks to the dynamic nature of Python that makes monkey patching possible, the
process happens at runtime without ever having to directly modify the source
code of the third-party library:>>>importgorilla>>>importdestination>>>@gorilla.patches(destination.Class)...classMyClass(object):...defmethod(self):...print("Hello")...@classmethod...defclass_method(cls):...print("world!")The code above creates two patches, one for each member of the classMyClass, but does not apply them yet. In other words, they define the
information required to carry on the operation but are not yet inserted into
the specified destination classdestination.Class.Such patches created with the decorators can then be automatically retrieved by
recursively scanning a package or a module, then applied:>>>importgorilla>>>importmypackage>>>patches=gorilla.find_patches([mypackage])>>>forpatchinpatches:...gorilla.apply(patch)See theTutorialsection from the documentation for more detailed examples
and explanations on how to use Gorilla.DocumentationRead the documentation online atgorilla.readthedocs.ioor check its source
in thedocdirectory.Out ThereProjects using Gorilla include:banamlflowAuthorChristopher Crouzet
<christophercrouzet.com>
Package: gorilla2d
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)# gorilla-2dcreated by [GorillaLab](empty)## Introduction
A 2D toolbox for learning task for Gorilla-Lab## Documents
- TODO## Installation
Run this command in project directory`sh python setup.py install(develop) `## Reference By
- [open-mmlab/mmcv](https://github.com/open-mmlab/mmcv)
- [open-mmlab/mmdetection](https://github.com/open-mmlab/mmdetection)
- [facebookresearch/detectron2](https://github.com/facebookresearch/detectron2)
Package: gorilla-cli
Gorilla CLIGorilla CLI powers your command-line interactions with a user-centric tool. Simply state your objective, and Gorilla CLI will generate potential commands for execution. Gorilla today supports ~1500 APIs, including Kubernetes, AWS, GCP,  Azure, GitHub, Conda, Curl, Sed, and many more. No more recalling intricate CLI arguments! 🦍Developed by UC Berkeley as a research prototype, Gorilla-CLI prioritizes user control and confidentiality:Commands are executed solely with your explicit approval.While we utilize queries and error logs (stderr) for model enhancement, we NEVER collect output data (stdout).Getting StartedYou can readily install Gorilla CLI via pip.pipinstallgorilla-cliUsageActivate Gorilla CLI withgorillafollowed by your task in plain English.For instance, to generate a file with 100 random characters, type:$gorillagenerate100randomcharactersintoafilecalledtest.txtor if you prefer, you can use quotes to avoid issues with string parsing:$gorilla"generate 100 random characters into a file called test.txt"Gorilla CLI will then generate candidate commands. Use the arrow keys to navigate through the options, then press enter to execute the chosen command.🦍WelcometoGorilla.Usearrowstoselect»cat/dev/urandom|envLC_ALL=Ctr-dc'a-zA-Z0-9'|head-c100>test.txtecho$(head/dev/urandom|LC_CTYPE=Ctr-dc'a-zA-Z0-9'|ddbs=100count=1)>test.txtddif=/dev/urandombs=1count=100of=test.txtSome more examples$gorillalistallmyGCPinstances
»gcloudcomputeinstanceslist--format="table(name,zone,status)"gcloudcomputeinstanceslist--formattablegcloudcomputeinstanceslist--format="table(name, zone, machineType, status)"$gorillagettheimageidsofallpodsrunninginallnamespacesinkubernetes
»kubectlgetpods--all-namespaces-ojsonpath="{..imageID}"kubectlgetpods--all--namespaceskubectlgetpod-A-ojsonpath='{range .items[*]}{"\n"}{.metadata.name}{"\t"}{.spec.containers[].image}{"\n"}{end}'How It WorksGorilla-CLI fuses the capabilities of various Language Learning Models (LLMs) likeGorilla LLM, OpenAI's GPT-4, Claude v1, and others to present a user-friendly command-line interface. For each user query, we gather responses from all contributing LLMs, filter, sort, and present you with the most relevant options.ContributionsWe welcome your enhancements to Gorilla CLI! If you have improvements, feel free to submit a pull request on our GitHub page.LicenseGorilla CLI operates under the Apache 2.0 license. More details can be found in the LICENSE file. We'd also like to extend our appreciation toquestionaryfor their fantastic UI!
Package: gorilla-core
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)# gorilla-core
A lightly library for computer vision research.created by [GorillaLab]([empty](https://github.com/Gorilla-Lab-SCUT))## Introduction
A toolbox for learning task for Gorilla-Lab## Documents
- [API](docs/API_manual.md)(Chinese)## Installation
You can install directly bypip`sh pip installgorilla-core`Run this command in project directory`sh python setup.py install(develop) `## Reference By
- [open-mmlab/mmcv](https://github.com/open-mmlab/mmcv)
- [open-mmlab/mmdetection](https://github.com/open-mmlab/mmdetection)
- [facebookresearch/detectron2](https://github.com/facebookresearch/detectron2)
- [rwightman/pytorch-image-models](https://github.com/rwightman/pytorch-image-models)# TODO
- [x] add utils
- [x] fix build
- [x] init BaseSovler
- [x] support registry
- [x] distributed
- [ ] hook design
- [ ] merging some timm components
- [ ] To be continue# Changelog
TODO
Package: gorillaml
Welcome to GorillaML's documentation!This is the application which allow individual, organization, developer, publisher to manage, publish, monitor webservices, machine learning api, custom forms and many more active development very easily.Installation.. code-block:: pythonpip install gorillamlDB InitializationAfter installation to initialized the application database we have to run below command in console... code-block:: pythongorillaml-canvas init-db.. warning:: Dont ignore or forget to run this command or else application stop working properly.Start Application ServerTo start GorillaML server run below command in terminal.. code-block:: pythongorillaml-canvas start-foreverIt will expose the application inhttp://127.0.0.1:5000Application LoginDefault username and password of the application isadminandadmin. After successfull login change your default
password as per your convenient time.Plugin DevelopmentGorillaML is created on top of Flask framework and this plugins are created based on Flask blueprint framework. You have full controll to play with gorillaml plugins using Flask blueprint for more details start readinghttps://flask.palletsprojects.com/en/1.1.x/blueprints/You will found sample plugins herehttps://github.com/washim/GorillaML_Plugins.. warning:: Plugin name and blueprint name should be same inside plugin.py. Thisplugin.pyandinit.pyis the mandatory to create gorillaml plugins. Dont changegorillamlvariable inside plugin.py
Package: goristock
goristock 台灣股市分析機器人Authors:ToomoreVersion:0.5 of 2011/10/05How it work.https://docs.google.com/present/view?id=dft5qcw9_95hd66b9djReport Issue or get involvedgoristock-dev →https://groups.google.com/group/goristock-devIssues →https://github.com/toomore/goristock/issuesMore info. →http://goristock.appspot.com/devChangeLog2011-10-05 v0.5main change:spread gae and grs from goristock.a87bede [issues #35] Build Buy or sell record.a76edcc Update ck4buy example.84fc5bd Rewrite ck4buy example.c7c9951 [issues #33] Update twseno and add inds no.14393dd Change License year from 2010 to 2011.1b3d105 [issues #31 #32] Build B4P model.2f9c23e [issues #30] Build 4 best buy point model.06bc671 [issues #30] Build ckMAO.7ccb454 Tiny change for good efficacy.d30fc52 Change SD,SDAVG,CV default days.(45days)a3afde3 Fixed a rev bug.d1a090c Add code note.b528885 [issues #22] Fixed a zone value type.7a12995 [issues #19] Fixed csv file open path.efa6425 [API] Fixed liststock fault.d9d8662 Fixed issues #9.b877a0a Translation to Chinese.b0ef262 Useing TWTime() for detecting open or not.
Package: gor-logger
The GorLogger packageThis Package is for the logging purpose for the multiprocessing/multithreading based python applications.
As current python logging module lack in the multiprocessing based applications.INSTALLATIONpip install gor_loggerUSAGEfrom gor_logger import GorLogger
log_obj = GorLogger()
logger = log_obj.getInstance('logger_name', 'log_file_name', './logs_directory', 'LOG_LEVEL')LOGGINGlogger.debug("This is debug message")
logger.info("This is info message")
logger.warning("This is warning message")
logger.error("This is error message")
logger.critical("This is critical message")IMPORTANTThis logger module is tested with python3.9 and also it works with TimeRotatingFileHandler with rotation based
on daily basis i.e separate log file for each day after midnight.
Package: gormanian
GormanianGormanian Calendar Calculator/ConverterWhat is it?Put simply, it is a library to calculate an alternative date structure based on the comedic sketch ofDave Gorman.  In an episode of 'Modern Life is Goodish', Dave Gorman proposed a new calendar format to replace the existing Gregorian calendar.  In particular, he takes umbridge at the fact that the length of a month varies, when all other units of time are fixed and identical.You can watch the video in questionhereon Dave Gorman's official YouTube channel.But why?Why not?  I happen to agree with the calendar, and decided to write this for a laugh.How to UseTo convert the current dateimport gormanian

response = gormanian.now()

print(response.as_string)To convert a specific dateUse the standard datetime format for any given date.from datetime import datetime
import gormanian

response = gormanian.convert(datetime(2000, 12, 1))

print(response.as_string)ISO-8601 format:You can also retrieve the date in ISO-8601 basic format.from datetime import datetime
import gormanian

response = gormanian.convert(datetime(2000, 12, 31))

print(response.isoformat)
Package: goroutine-py
English |中文goroutine-py🚀 An Asyncio-based concurrency library for Python.​	Easy concurrency just like goroutine without worry about thread and coroutine in Python.IntroductionWithinggoroutine.app.goyou can run a coroutine or a func asynchronously.Main functiongo:go(obj: callable, *args, callback: callable = None, lock: bool = False)​obj:Takes both callable coroutinefunction and func as object.​*args:Arguments for your obj.​callback:Attaches a callable that will be called when the future finishes.​lock:Thread safe if True. It can slow your program.​		 This argument only work for "func" not "coroutinefunction".Getting StartedSupport:Python 3.7 / 3.8 / 3.9 / 3.10 / 3.11 / 3.12InstallationFirst you have to install goroutine-py like this:pip install goroutine-pyQuick TutorialThe primary entity of goroutine-py isgoroutine.app.go.
You can simply start using goroutine-py like this:First, define your tasks:import asyncio
import functools
import time
from goroutine.app import go

# A normal func
def task_1(n=2):
    time.sleep(n)
    print('Task_1_done')
    return 'Result_1'# A coroutinefunction
async def task_2(n=1):
    await asyncio.sleep(n)
    print('Task_2_done')
    return 'Result_2'# Callback func
def callback(future, arg=None):
    '''
    At least ONE Parameter "future" is required.
    This future is a concurrent.futures.Future.
    Use functools.partial() to give arguments for your callback func.
    '''
    print(future.result(),arg)After you defined all your tasks and callback, you can go like this:go(task_1)
go(task_2)
go(task_1, 4, callback=callback)
go(task_2, 2, callback=functools.partial(callback,arg='a'))
print('END')Output :>>>
END
Task_2_done
Task_1_done
Task_2_done
Result_2 a
Task_1_done
Result_1 NoneLicenseThis project is licensed under the MIT License - see theLICENSEfile for details.
Package: gorpy
gorpyGood Old Regex and Python[Read the Docs] (https://gorpy.readthedocs.io/en/latest/index.html)FeaturesWritten entirely in Python.Grep-style interface for searching textPipes and union operator allow more advanced filtering of files and directory trees so that you only see the files you wantEasily look at text inside PDFs and Word documentsParse XML and HTML as HTML and XML rather than just plain textPowerful and extensible JsonPath implementationHarness the power of pandas to analyze tabular documents (e.g., csv, fwf) using the same JsonPath query languageEasily update, delete, and open files found by the toolHow to useInstall Python 3.6 or newer.Install# or PyPIpipinstallgorpyUse command-line interface to do gorp stuff:pythongorp.py<query>or enter an interactive session:pythongorp.py
gorp><query># results# ...# more resultsgorp><anotherquery>or access gorp programmatically in a Python session (see gorp.readfiles.GorpSession)ContributingBe sure to read thecontribution guidelines.Other stuffTODO: add code coverage link (the below link is broken)
(https://codecov.io/github/URL-OF-PROJECT?branch=master)](https://codecov.io/OTHER-URL-OF-PROJECT)gorpy_logo.PNG and gorpy_logo_small.PNG modified fromhttps://commons.wikimedia.org/wiki/File:Gorp.jpgandhttps://www.python.org/static/community_logos/python-logo-master-v3-TM.png
Package: gorse
gorseInstallingInstall and update using pip:$ pip install -U gorseA Simple Examplefrom gorse import route, run, template


@route("/hello/<name>")
def hello(name):
    return template("<b1>Hello {{name}}</b1>!", name=name)


@route("/")
def index():
    return "<h1>Hello world!</h1>"

run(host="127.0.0.1", port=8000, debug=True)LinksDocumentation:https://github.com/MarkHoo/gorsePyPI Releases:https://pypi.org/project/gorse/Source Code:https://github.com/MarkHoo/gorseIssue Tracker:https://github.com/MarkHoo/gorse/issuesWebsite:https://pypi.org/project/gorse/
Package: gorun
(c) Peter Bengtsson,mail@peterbe.com, 2009-2012
License: PythonUsing (py)inotify to run commands when files changeTired of switching console, arrow-up, Enter, switch console back for
every little change you make when you’re writing code that has tests?
Running withgorun.pyenables you to just save in your editor and
the tests are run automatically and immediately.gorun.pydoes not use a slow pulling process which keeps taps on
files modification time. Instead it uses theinotifywhich is “a Linux kernel
subsystem that provides file system event notification”.InstallationThis will only work on Linux which has the inotify module enabled in
the kernel. (Most modern kernels do)pip install gorunThis will installpyinotify.Then, create a settings file, which is just a python file that is expected to
define a variable calledDIRECTORIES. Here’s an example:DIRECTORIES = (
   ('some/place/', './myframework test --dir some/place'),
   ('some/place/unitests.py',
    './myframework test --dir some/place --testclass Unittests'),
   ('/var/log/torrentsdownload.log',
    'growl downloads --logfile /var/log/torrentsdownload.log'),
)Save that file as, for example,gorun_settings.pyand then start it
like this:$ gorun.py gorun_settingsConfigurationOnce you’ve set gorun to monitor a directory it will kick off on any
file that changes in that directory. By default things like autosave
files from certain editors are automatically created (e.g. #foo.py# or
foo.py~) and these are ignored. If there are other file extensions you
want gorun to ignore add this to your settings file:IGNORE_EXTENSIONS = ('log',)This will add to the list of already ignored file extensions such as.pyc.Similarly, if there are certain directories that you don’t want the
inotify to notice, you can list them like this:IGNORE_DIRECTORIES = ('xapian_index', '.autosavefiles')DisclaimerThis code hasn’t been extensively tested and relies on importing
python modules so don’t let untrusted morons fiddle with your dev
environment.TodoWhen doing Django development I often run on single test method over
and over and over again till I get rid of all errors. When doing this
I have to change the settings so it just runs one single test and when
I’m done I go back to set it up so that it runs all tests when adjacent
code works.This is a nuisance and I might try to solve that one day. If you have
any tips please let me know.