Saravanan666/pypi-org huggingface dataset:
Package: gregorian-months
Gregorian MonthsConduct with the Gregorian calendar monthsUsageGet each month number by its name:fromgregorian_monthsimportget_numberget_number("July")# Will return `7`get_number("January")# Will return `1`get_number("October")# Will return `10`The package supports all cases:fromgregorian_monthsimportget_numberget_number("july")# Will return `7`get_number("JANUARY")# Will return `1`get_number("OcToBer")# Will return `10`InstallationUse the package managerpipto install the package:pipinstallgregorian-months
Package: gregory
GregoryPython Framework to Manage Time Series structured as one-level dictionaries.OverviewThis framework is an extension of theoutatimepackage to facilitate operations on time series built as dictionaries.The main requirement is that thedataattribute of the dataclassTimeSeriesDatais a one-level dictionary.E.g.TimeSeriesData(
    day=date('2022-04-28'),
    data={
        'gold': 1887.77,
        'silver': 23.03
    }
)Some features are added such as:interpolation of missing datatrend and seasonality calculationmethods of aggregation between dictionariesotherInstallationTo install it use:pip install gregoryor download the last git version and use:python setup.py installFramework Structuregregory
├── dataclass
│   └── time_series_data.py --> Class used to manage daily data.
│
├── granularity
│   ├── granularity.py --> Set of classes used for managing time intervals of different length.
│   ├── granularity_factory.py --> Factory class for creating granularity objects.
│   └── utils.py --> Utils related to granularities.
│
├── timeseries
│   ├── batches.py --> Set of methods to operate on time series dividing them into batches.
│   ├── expr.py --> Set of operations between time series.
│   ├── processing.py --> Set of methods to elaborate time series.
│   └── time_series.py --> Core class that represents a series of daily records.
│
└── util
    ├── agenda.py --> Utils related to calendar info and evalutations.
    ├── bisect.py --> Utils related to binary search.
    ├── decorators.py --> Useful decorators.
    ├── dictionaries.py --> Utils related to operations on dictionaries.
    └── relativedelta.py --> Class that extends relativedelta with useful properties.LicenseMIT license, seeLICENSEfile.
Package: gregory-online
Project gregoryonlineexperimental code to online survey root spectra from THTTPServerLast notice:changing to keybssh NOWUsageBased on ~/.config/gregoryonline/cfg.json{
 "placeholder": true,
 "filename": "~/.config/gregory_online/cfg.json",
 "spectrum": "b0c00",
 "udp_ip": "127.0.0.1",
 "server": "x.x.x.x",
 "poll_time": 5
}it connects to./bin_gregory_online.py
# OR override the server and spectrum name
./bin_gregory_online.py -s 127.0.0.1 -h b0c00InstallGithub?pip3 in futureUI ComponentsThere are two:topbarkeyenterThe topbar runs in the background, provides two bars. The second one is
the keyboard input bar.Engines of fetchkeep getting histo from serverkeep historical spectra and be prepared to show difkeep track of age and show rateshow bg spectrum rate for comparisonVersion 2histoglobalcont.py    Container for histograms
histonpops.py         operations between np ad th1
histoio.py            load and save
bingregoryonline.pyconfig.pyfetchnp.pygetspe.pykeyenter.pymockserver.pyrebin.pysetup.pytopbar.pyutilone.pyversion.py
Package: gregtech-flow
❓ What is it?This is a fork of OrderedSet86'sgtnh-flow. In addition to the functionalities of the original tool, this fork has:Extended formatting of projectsAdded stylization add formatting of graphsStandards to increase readabilityA custom command line interfaceFull documentationTo view the full documentation see the officialGT: Flow website.📖 SamplesSamples of the graphs included in the repository.Samples
Package: grein-loader
grein_loaderPython package to automatically download datasets from GREINhttp://www.ilincs.org/apps/greinIntroductionGrein Loader enables users to access data from the GREIN website by using the GSE identification numberInstallationInstall the package from pypi by using:pip install grein_loaderUsageThe package allows you to download the description, metadata and the raw counts of a GREIN dataset based on the GSE id.
The datasets from GREIN are publicly available and can be accessed via theGREIN webpage.
Each dataset uses an GEO accession id which allows you to access its data.load_dataset()geo_accession = "GSE112749"
description, metadata, count_matrix = grein_loader.load_dataset(geo_accession)Input/Output parametersInput parameter:
| gse_id | string | GEO accession id

Output parameter: 
| description  | dictionary      | description of dataset
| metadata     | dictionary      | metadata of dataset
| count_matrix | pandas dataframe| numpy array of raw countsload_overview()loads a number of datasets from Grein, the datasets are also listed on the main paige of GREINnumber_of_datasets = 10
overview = loader.load_overview(number_of_datasets)The function returns a list of dictionaries, each dictionary contains the GSE id, number of samples, species and description
provided from GREIN.Input parameter:
number_of_samples

Output parameter: 
list of dictionaries with, "geo_accession", no_samples", "species","title", "study_summary"
Package: greins
AboutGreins is aGunicornapplication which makes it easy to configure and
manage any number ofWSGIapps in one server daemon. It aims to simplify
the process of setting up any number of system-wideGunicorndaemons.InstallationGreins requires a working version ofGunicorn. It is recommended to read and
understand theGunicorninstallation instructions before using Greins.Install from sources:$ python setup.py installInstall as an rpm:$ make rpmWhatever was here before was wrong. There is no place in PyPI for Greins.
The most useful aspects of Greins are in the packaging, since it aims to
facilitate deployment of Gunicorn and adds no particular functionality itself.There’s an init script in etc/init aims to be LSB-compliant and packaging
for other distributions and systems is an ongoing effort.Those wishing to deploy Greins for their own infrastructure are encouraged
to contribute to the development.Basic UsageGreins installs one command line script invoked asgreins.greinsOptions are the same as forGunicornwith one exception: the single
APP_MODULE argument is replaced by APP_DIR, a directory containing python
source files as described in the following section.Application ConfigurationApplications should be configured by placing a python source file in the
configuration directory. This file should populate a dictionary in the global
scope calledmountswhich maps address prefixes (or ‘mount points’) to
WSGI handler functions.These files are evaluated just like aGunicornconfig file. Server hooks
are valid in these configuration files and work as inGunicorn. Other options,
such as logging and worker configuration, are ignored and should be configured
globally for the Greins application.As a convenience, a file namemyappwhich does not define anymountswill try to importmyapp:applicationand mount it underneath the path/myapp.It should be possible to write an application forGunicornand then place
aGunicornconfiguration file inside the configuration directory for Greins
to begin using it within Greins immediately, provided that the config file name
matches a module in the python path which exportsapplicationas aWSGIcallable.ExamplesThe examples directory runs a singlegreinsapplication from the filetest.pywhich demonstrates loading several routes as well as using thegunicornserver hooks. To run the examples, launchgreinsfrom the
directory aboveexampleswith:$ greins examplesThegreinscommand acceptsgunicornoptions. For example:$ greins -kgevent -b0.0.0.0:8080 examplesLICENSEGreins is released under the MIT License. See theLICENSEfile for more
details.
Package: greml
GremlMake HTML greppable!A simple tool to allow you togrep HTML.InstallationThe recommended way to install is to usepipx:pipx install gremlUsageSpecify a HTML document, either piped as stdin, or a file or HTTP request and aselector (provided by Soup Sieve).The output may be the text of the elements, a JSON representation of the element (including all attributes) that may be parsed further usingjqor the value of specific attributes.%  greml --help

 Usage: greml [OPTIONS] [INPUT_PATH] [SELECTOR]

╭─ Arguments ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│   input_path      [INPUT_PATH]  Input file path or URL. If not specified uses stdin. [default: (stdin)]                                                           │
│   selector        [SELECTOR]    HTML selector [default: None]                                                                                                     │
╰───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --display                     TEXT                             How to display, either 'text', 'json' or 'attr.ATTR' [default: text]                               │
│ --version             -v                                                                                                                                          │
│ --install-completion          [bash|zsh|fish|powershell|pwsh]  Install completion for the specified shell. [default: None]                                        │
│ --show-completion             [bash|zsh|fish|powershell|pwsh]  Show completion for the specified shell, to copy it or customize the installation. [default: None] │
│ --help                                                         Show this message and exit.                                                                        │
╰───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯Exampless% greml https://www.yourlifedoncaster.co.uk/trees-and-woodlands '#treeCounter'
108,000% greml https://github.com/adamckay 'img[alt^="Achievement: "]' --display attr.alt | sort | uniq
Achievement: Arctic Code Vault Contributor
Achievement: Pull Shark
Achievement: Quickdraw
Achievement: YOLO
Package: gremlin-dsl
gremlin-dslA small example Gremlin DSL for the toy Modern database.AboutThere aren't many complete examples of building adomain specific language (DSL)using the Gremlin Python driver.
This is a small example Python package that implements a DSL for the Modern toy database, served using the Gremlin Server.Usage NotesThe first necessary step is to install the Gremlin server:$curl-ogremlin-server.ziphttps://dlcdn.apache.org/tinkerpop/3.6.0/apache-tinkerpop-gremlin-server-3.6.0-bin.zip
$unzipgremlin-server.zip
$rm-rfgremlin-server.zipThe link for the latest release of the Gremlin Server can be foundhere.Next, start the server with the Modern config:$cdapache-tinkerpop-gremlin-server-3.6.0/
$bin/gremlin-server.shconf/gremlin-server-modern.yamlDocs on using the Gremlin Server can be foundhere.The package can then be installed from PyPi:$pipinstallgremlin-dslWith the server running, you can use to the DSL to write queries against the Modern database:fromgremlin_python.driver.driver_remote_connectionimportDriverRemoteConnectionfromgremlin_python.process.anonymous_traversalimporttraversalfromgremlin_dsl.core_dslimportget_db_endpointfromgremlin_dsl.core_dslimportSocialTraversalSourcedefmain():endpoint=get_db_endpoint()connection=DriverRemoteConnection(endpoint,"g")social=traversal(SocialTraversalSource).with_remote(endpoint)print(social.persons("marko").knows("josh"))connection.close()if__name__=="__main__":main()
Package: grep-ast
grep-astGrep soure code files and see matching lines with
useful context that show how they fit into the code.
See the loops, functions, methods, classes, etc
that contain all the matching lines.
Get a sense of what's inside a matched class or function definition.
You see relevant code from every layer of the
abstract syntax tree, above and below the matches.Grep-AST is built withtree-sitterandtree-sitter-languages.
So it supports a lot of popularcode languages.Installpython-mpipinstallgit+https://github.com/paul-gauthier/grep-ast.gitUsageBasic usage:grep-ast[pattern][filenames...]Full options list:usage: grep_ast.py [-h] [-i] [--color] [--no-color] [--encoding ENCODING] [--languages] [--verbose]
                   [pat] [filenames ...]

positional arguments:
  pat                  the pattern to search for
  filenames            the files to display

options:
  -h, --help           show this help message and exit
  -i, --ignore-case    ignore case distinctions
  --color              force color printing
  --no-color           disable color printing
  --encoding ENCODING  file encoding
  --languages          print the parsers table
  --verbose            enable verbose outputExamplesHere we search for"encoding"in the source to this tool:Here we search for"TreeContext"in the source to this tool:
Package: grepath
grepathutility prints full path to executables that match
given file-pattern or regular expression.Examples:To print executables that contain ‘pdf’ anywhere in their name:$ grepath pdf
/usr/bin/ps2pdf12
/usr/bin/ps2pdf13
...[snip]...
/usr/bin/simpdftex
/usr/bin/dvipdfTo find executables that don’t have ‘e’ after ‘win’ in their name:C:\> grepath -e "win[^e]"
C:\windows\system32\winhlp32.exe
C:\windows\system32\winver.exe
C:\windows\winhlp32.exe
C:\windows\winhelp.exeIf*.pyfiles are not associated withpython.exethen the
script can be invoked using:C:\> python \path\to\grepath.py --helpTo print all available options, type:$ grepath --helpFiles are licensed under the MIT License. See the file MIT-LICENSE.txt
for details.The latest version is athttp://gist.github.com/79233
Package: grepenv
grepenvgreps your env 🔎AboutA simple tool to search through your environment.Provides additional options for highlighting, searching specifically keys or values, and extracting values from best match keys.Installationgrepenvcan be installed using pip, butpipxis recommended:pipxinstallgrepenvThis installs thegrepenvshell script:grepenv--helpUsagegrepenvtakes a regex pattern, and matches it against currently available environment variables.Callinggrepenv --examplewill show some example usage.$grepenvxdg# Will find any key or value that contains the letters xdg (lower or upper case).$grepenv"_api_(key|token)_"-k# finds any environment that looks like an api key. Searches only keys.GITHUB_API_TOKEN=abc_NlNhalNDL78NAhdKhNAk78bdf7fOPENAI_API_KEY=123_abcdefghijklmno$grepenv-fkgit# find-key 'git'- finds all keys matching the pattern 'git' and gets their values.123_abcdefghijklmnopDevelopmentThis repo usespoetryas a build system, andinvokefor task running.invcan then be used to run as follows:$invlint
$invtest$invbuild
$inv--list# Shows available commandsYou can achieve similar results with a one liner bash alias, but after having rewritten that alias on every machine I've used, I decided to turn it into a package for maintainability.Another language might have been more fun to use, but since pip is by FAR the most available package manager (compared to say cargo), here we are.
Package: grepexercises
Grep ExercisesThis TUI application includes 50+ questions meant to be solved usingGNU grep(or alternate implementations likeripgrep). Some exercises will require you to combinegrepwith other standard commands such ascat,wcandfind.Note:This application is intended to be run in a Linux-like environment. You might still be able to solve the exercises on other platforms, but I do not know if that'll work.ScreenshotGuideSeeapp_guide.mdLicenseCode snippets are licensed underMIT LICENSEExercise questions and associated files (likequestions.json) are licensed underCreative Commons Attribution-NonCommercial-ShareAlike 4.0 International License
Package: greps
grepsgreps is a super simple ipython magic that allow you to usegrepover IPython output.installationpipinstallgrepsmanually loading:# Inside an IPython shell
%load_ext grepsAutomatic loading:echo"c.InteractiveShellApp.extensions = ['greps']">~/.ipython/profile_default/ipython_config.pyUsageOn previous output:In [1]: {i:i for i in range(3)}
Out[1]: 
{0: 0,
 1: 1,
 2: 2,
}
 
In [2]: %greps 1
Out[2]: ' 1: 1,\n'On specific output line:In [1]: 1
Out[1]: 1

In [2]: 2
Out[2]: 2

In [3]: 3
Out[3]: 3

In [4]: 4
Out[4]: 4

In [5]: %greps -l 2 2
Out[5]: '2\n'
Package: grepsr-cli
A Cli tool for Grepsr DevelopersInstallation$ pip install grepsr-cliUsagepassing parameters toamazon_comservice.gclicrawlertest-samazon_com-p'{"urls":["https://amazon.com/VVUH4HJ","https://amazon.com/FV4434"]}'if JSON is complex, use file instead# contents of /tmp/amazon_params.json
{"urls": ["https://amazon.com/VV%20UH4HJ"], "strip": ["'", "\"", "\\"]}

gcli crawler test -s amazon_com --params-file '/tmp/amazon_params.json'Hacks Used.If the json parameter has a space, it might break parameter parsing.
If the json parameter has a dash-and any character after it has a space, it will break parameter parsing.
Cause: no double quoting around $@ inrun_service.php:5:49hereThis is fixed hackily by replacing string with its unicode \u0020 sequence. This works beacause $@ does not split on \u0020.inject custom command.Say, for example you wanted to a inject a php function so that it could be called from inside you service_code when testing locally.
Note: All these files should only be created inside~/.grepsr/tmp. Creating it outside will not work.Create a file calledinject.phpinside~/.grepsr/tmp/Implement your function inside~/.grepsr/tmp/inject.phpfunction addRowLocal($arr) {......}Create a file calledinject.shinside~/.grepsr/tmp/inside inject.sh add:alias php='php -d auto_prepend_file=/tmp/inject.php'Note: the file location is/tmp/inject.phpinstead of~/.grepsr/tmp/inject.php.
This is because, the local path~/.grepsr/tmpgets mapped to/tmpin the docker container.
Andinject.shruns inside docker, instead of the local filesystem.
5. Add an entry in~/.grepst/config.ymllike so:php:
        ...
        sdk_image: ...
        pre_entry_run_file: inject.sh      # relative and limited to the tmp/ dirNow you can useaddRowLocal()in your any of your files.public function main($params) {...$arr = $this->dataSet->getEmptyRow();addRowLocal($arr); // won't throw error...}DevelopmentBe sure to uninstall gcli first, withpip uninstall grepsr-cligitclonegit@bitbucket.org:zznixt07/gcli.gitgrepsrclicdgrepsrcli
pipinstall-e.Features Addedstash untracked files to avoid failure when applying stash.drop stash after pushed successully. Before this, all stashes were always kept.run a custom shell file before running your crawler. This allows possiblity like always injecting a php function in all your crawlers.auto addDependencies: ...that your crawler class extends (dependecies that are not extended by crawler classes but used elsewhere is upcoming)
Package: greptable
Descriptiongreptablegenerates a plain-text list of your servers, databases and tables,
so that you can easily find where the fuck that table is, with your favorite
search tools, likegrep.This is especially useful if you are dealing with many servers and databases.Requirementsgreptableworks on both Python 2 and Python 3.The only dependency isSQLAlchemy, and it should support the same databases.UsageFor global options rungreptable-h.All commands need a configuration file; see theConfigurationsection below.Listing tablesTo list the tables, rungreptable dump.You can change the configuration file path with the-c(also known as--config).
By default, it uses~/.config/greptable.confif it exists,
otherwisegreptable.conffrom the current directory.The tables are listed to the standard output by default.
The-o(also known as--output) option can dump in a file instead.Example:greptable-cgreptable.conf dump-otables.txtFor full help on options rungreptable dump-h.Opening tablesgreptablelets you open a table or schema in your favorite admin interface,
built from a configured URL template.This is thought for phpMyAdmin, but should work with other tools, even
non-web (if not, please provide examples or patches).Using it is as simple as runninggreptable openfollowed
by the selected output of agreptable dump.
You can even dogreptable open $(greptable dump|grep mytable).The URL will be opened byxdg-open. If it’s not opening the wanted
browser, you should set theBROWSERenvironment variable.If you only want to show the URL, and not open it automatically, use the-s(also known as--show) option.ConfigurationThe configuration is a standard INI file.
Section headers areSQLAlchemy URLs.For example:[mysql://user:password@server1]
[sqlite:///db.sqlite]greptablewill try to prettify server URLs, but you can also force a name.For example:[mysql://user:password@server1]
[sqlite:///db.sqlite]
name = dbFor theopensubcommand, you can provide both aopenschemaandopentableoption. If theopenschemaoption is not provided,opentablewill be used,
with the table parameter being an empty string.The variable substitution uses the Pythonformat()syntax.For example:[mysql://user:password@server1]
opentable = https://penguincorp.com/pma/index.php?server=0&db={schema}&table={table}

[mysql://user:password@server2]
opentable = https://penguincorp.com/pma/index.php?server=1&db={schema}&table={table}

[otherdb://user:password@server]
name = srv0
openschema = https://penguincorp.com/otherdb/{server}/tables/{schema}
opentable = https://penguincorp.com/otherdb/{server}/showtable/{schema}/{table}DevelopmentContributions can be sent in the form of git patches, tolaurent@bachelier.name.
Package: greptimeai
greptimeaiObservability and analytics tool for LLM framework, service, etc.InstallationTo start, ensure you have Python 3.8 or newer. If you just want to use the package, run:pipinstall--upgradegreptimeaiSetupTo get started, create a service by registeringgreptimeai, and get:hostdatabasetokenSet it as theGREPTIMEAI_xxxenvironment variable before using the library:exportGREPTIMEAI_HOST=''exportGREPTIMEAI_DATABASE=''exportGREPTIMEAI_TOKEN=''or you can pass them via parameters.ExampleslangchainopenaiYou can find complete guides ongreptimeai-cookbookContributingContributions are highly encouraged!Pull requests that add support for or fix a bug in a feature will likely be accepted after review.LicensingAll code in this repository is licensed under theApache License 2.0.Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you,
as defined in the Apache-2.0 license, shall be licensed as above, without any additional terms or conditions.
Package: greptime-cloud-quick-start
IntroductionThis is a quick start demo forGreptimeCloud. It collects the system metric data such as CPU and memory usage through Opentelemetry and sends the metrics to GreptimeCloud. You can view the metrics on the GreptimeCloud dashboard.Quick StartUse the following command line to start it in Python 3.10+ without cloning the repo:pipxrun--no-cachegreptime-cloud-quick-start-e<endpoint-url>-db<dbname>-u<username>-p<password>Or you can clone the repo and run it:pipinstall-rrequirements.txt
pythonstart/main.py-e<endpoint-url>-db<dbname>-u<username>-p<password>ReleaseChange the version inpyproject.toml.Commit and push the changes.Create a tag with the version and push it to the remote repository.gittagv<major>.<minor>.<patch>
gitpushoriginv<major>.<minor>.<patch>Build and publish the package to PyPI:python-mbuild
python-mtwineuploaddist/*
Package: grepurl
grepurlis a command line tool that extracts URLs from a website (or a
local HTML file).Usagegrepurl http://example.com/
grepurl -a http://example.com/foo.htm # only extract from <a> tags (i.e. links)
grepurl -i http://example.com/bar.htm # only extract from <img> tags (i.e. images)
grepurl -r "\.py$" http://example.com/ # only extract links that end in '.py'LicenseGPLv2 or later.AuthorsGerome Fournier (original author). His implementation is only available via theInternet Archive.
Arne Neumann (added -l option for local files, minor changes).