Saravanan666/pypi-org huggingface dataset:
Package: grimoire
grimoireThe grimoire pacakage contains libraries and scripts for Biological sequence analysis.DisclaimerThe current developent is highly volatile and not ready for public consumption.Design ConsiderationsThe code is designed with the folllowing analyses in mind:Gene structure prediction using hidden Markov models and variantsGenome annotation quality controlStructure-function relationships in sequences (e.g. IME)ProgramsProgram names are themed after spell names from the classic RPG
"Wizardry: Proving Grounds of the Mad Overlord."NameMeaningFunctioncalfox-raygenome annotation reporterkandilocategenome annotation viewerhamanchangegenome slicermilwalighthmm buiderdumapicclarityhmm grapherhalitofirebasic hmm decodermahalitobig fire2-pass gene decodermorlisfearannotation comparer (simple)mogrefironsequence generatormamorlisgreat fear(planned complex annotation comparer)mahamanchange(planned multi-genome slicer)malorapport(planned genome lifter)lahalitotorch(planned full genome decoder)tiltowaitexplosion(planned multi-genome decoder)zilwandispel(planned profile/alignment decoder)latumapicidentify(planned region-ifier)ContributorsIan Korf (iankorf)Hannah Lyman (hslyman)Alex Kramer (aklreaxmer)Qijia Liu (joyliu-q)Jack Yu (Angraygs)AcknowledgementsThanks to M. O. Trebor and E. W. Werdna for inspiration.
Package: grimoire-elk-public-inbox
GrimoireELK public-inbox pluginpublic-inbox archive plugin for GrimoireELK.RequirementsPython >= 3.8You will also need some other libraries for running the tool, you can find the
whole list of dependencies inpyproject.tomlfile.InstallationThere are several ways to install grimoire-elk-public-inbox on your system: packages or source
code using Poetry or pip.PyPIgrimoire-elk-public-inbox can be installed using pip, a tool for installing Python packages.
To do it, run the next command:$ pip install grimoire-elk-public-inboxSource codeTo install from the source code you will need to clone the repository first:$ git clone https://github.com/bitergia-analytics/grimoirelab-elk-public-inbox
$ cd grimoirelab-elk-public-inboxThen use pip or Poetry to install the package along with its dependencies.PipTo install the package from local directory run the following command:$ pip install .In case you are a developer, you should install grimoire-elk-public-inbox in editable mode:$ pip install -e .PoetryWe usepoetryfor dependency management and
packaging. You can install it following itsdocumentation.
Once you have installed it, you can install grimoire-elk-public-inbox and the dependencies in
a project isolated environment using:$ poetry installTo spaw a new shell within the virtual environment use:$ poetry shellLicenseLicensed under GNU General Public License (GPL), version 3 or later.
Package: grimoire-kidash
Kidash is a prototype of a tool for managing Kibana dashboards from the
command line. It is a part ofGrimoireLab.UsageGet a list of all options with:$ kidash.py --helpFor the names of the files containing panels definitions (JSON panel
files), kidash supports both importing them from local directories, of
from thegrimoirelab-panelsPython package, if installed. In fact,
that package is a dependency of kidash, which means that if you
installed via pip, it will always be present.The algorith for finding a JSON panel file is, roughly:If the specified path (such aspanels/json/git.jsonorgit.json) is found relative to the local directory, use it.If not found, if the specified path starts withpanels/json/,
remove that part and look for the panel file in thegrimoirelab-panelspackage.If not found, look for the specified path directly in thegrimoirelab-panelspackage.For example:$ kidash.py --elastic_url-enrich http://localhost:9200 \
  --import git.jsonwill look for a filegit.jsonin the current directory, and if not
found, forgit.jsonin thegrimoirelab-panelsPython package, if
installed.Source codeThe source code is for now a part ofGrimoireELK.
Package: grimoirelab-toolkit
GrimoireLab ToolkitToolkit of common functions used across GrimoireLab projects.This package provides a library composed by functions widely used in other
GrimoireLab projects. These function deal with date handling, introspection,
URIs/URLs, among other topics.RequirementsPython >= 3.8You will also need some other libraries for running the tool, you can find the
whole list of dependencies inpyproject.tomlfile.InstallationThere are several ways to install GrimoireLab Toolkit on your system: packages or source
code using Poetry or pip.PyPIGrimoireLab Toolkit can be installed using pip, a tool for installing Python packages.
To do it, run the next command:$ pip install grimoirelab-toolkitSource codeTo install from the source code you will need to clone the repository first:$ git clone https://github.com/chaoss/grimoirelab-toolkit
$ cd grimoirelab-toolkitThen use pip or Poetry to install the package along with its dependencies.PipTo install the package from local directory run the following command:$ pip install .In case you are a developer, you should install GrimoireLab Toolkit in editable mode:$ pip install -e .PoetryWe usepoetryfor dependency management and
packaging. You can install it following itsdocumentation.
Once you have installed it, you can install GrimoireLab Toolkit and the dependencies in
a project isolated environment using:$ poetry installTo spaw a new shell within the virtual environment use:$ poetry shellLicenseLicensed under GNU General Public License (GPL), version 3 or later.
Package: grimoireml
GrimoireMLGrimoireML is an open-source side project aimed at exploring and experimenting with machine learning and data science. It's a playground for enthusiasts, learners, and anyone interested in diving into the world of data. Feel free to explore, contribute, or just have fun with it!InstallationYou can clone the repository and install GrimoireML locally:pipinstallgrimoiremlImportingimportgrimoiremlasgml# Now you can use the 'gml' alias to access GrimoireML's functions and classesContributingWant to contribute? Great! Feel free to fork the project, make your changes, and submit a pull request. Check outCONTRIBUTING.mdfor more details.LicenseGrimoireML is licensed under the MIT LicenseSupportDo you have any questions or run into issues? Open an issue on ourGitHub repository.AcknowledgementsA big shoutout to everyone who has played around with GrimoireML, shared ideas or contributed in any way.InspirationGrimoireML draws heavy inspiration from well-established machine learning libraries such asscikit-learnandTensorFlow. The design principles, algorithms, and overall approach are influenced by these pioneering projects. We encourage users to explore these libraries as well, and we express our gratitude to the developers and contributors of scikit-learn and TensorFlow for their work in the field of machine learning.Enjoy experimenting with GrimoireML!
Package: grimoire-reports
GrimoireLab ReportsThe aim of this project is the automatic generation of reports from the
enriched indexes with items from perceval data sources (git commits,
github pull requests, bugzilla bugs …) enriched using GrimoireELK.To follow the basic step you need the enriched indexes in the Elastic
Search provided as param to the report tool.The basic steps creating a report for git, gerrit, its and mls data
sources from April 2015 to April 2017 by quarters is:bin/report-g--data-sourcesgitgerrititsmls-u<elastic_url>-s2015-04-01-e2017-04-01-dproject_data-iquarterand the PDF is generated in project_data/report.pdf_UsageUse-hflag to show usage as follows:$ > bin/report -h
-d DATA_DIR, --data-dir DATA_DIR
                        Directory to store the data resultsParams:-d,--data-dir: directory to store data files that will be used to
create the report PDF file (csv and eps files containing metrics
results).
Package: grimp
Builds a queryable graph of the imports within one or more Python packages.Free software: BSD licenseQuick startInstall grimp:pip install grimpInstall the Python package you wish to analyse:pip install somepackageIn Python, build the import graph for the package:>>> import grimp
>>> graph = grimp.build_graph('somepackage')You may now use the graph object to analyse the package. Some examples:>>> graph.find_children('somepackage.foo')
{
    'somepackage.foo.one',
    'somepackage.foo.two',
}

>>> graph.find_descendants('somepackage.foo')
{
    'somepackage.foo.one',
    'somepackage.foo.two',
    'somepackage.foo.two.blue',
    'somepackage.foo.two.green',
}

>>> graph.find_modules_directly_imported_by('somepackage.foo')
{
    'somepackage.bar.one',
}

>>> graph.find_upstream_modules('somepackage.foo')
{
    'somepackage.bar.one',
    'somepackage.baz',
    'somepackage.foobar',
}

>>> graph.find_shortest_chain(importer='somepackage.foobar', imported='somepackage.foo')
(
    'somepackage.foobar',
    'somepackage.baz',
    'somepackage.foo',
)

>>> graph.get_import_details(importer='somepackage.foobar', imported='somepackage.baz'))
[
    {
        'importer': 'somepackage.foobar',
        'imported': 'somepackage.baz',
        'line_number': 5,
        'line_contents': 'from . import baz',
    },
]External packagesBy default, external dependencies will not be included. This can be overridden like so:>>> graph = grimp.build_graph('somepackage', include_external_packages=True)
>>> graph.find_modules_directly_imported_by('somepackage.foo')
{
    'somepackage.bar.one',
    'os',
    'decimal',
    'sqlalchemy',
}Multiple packagesYou may analyse multiple root packages. To do this, pass each package name as a positional argument:>>> graph = grimp.build_graph('somepackage', 'anotherpackage')
>>> graph.find_modules_directly_imported_by('somepackage.foo')
{
    'somepackage.bar.one',
    'anotherpackage.baz',
}Namespace packagesGraphs can also be built fromportionsofnamespace packages. To do this, provide the portion name, rather than the namespace name:>>> graph = grimp.build_graph('somenamespace.foo')What’s a namespace package?Namespace packages are a Python feature allows subpackages to be distributed independently, while still importable under a shared namespace. This is, for example, used bythe Python client for Google’s Cloud Logging API. When installed, it is importable in Python asgoogle.cloud.logging. The parent packagesgoogleandgoogle.cloudare both namespace packages, whilegoogle.cloud.loggingis known as the ‘portion’. Other portions in the same namespace can be installed separately, for examplegoogle.cloud.secretmanager.Grimp expects the package name passed tobuild_graphto be a portion, rather than a namespace package. So in the case of the example above, the graph should be built like so:>>> graph = grimp.build_graph('google.cloud.logging')If, instead, a namespace package is passed (e.g.grimp.build_graph('google.cloud')), Grimp will raiseNamespacePackageEncountered.
Package: grinder_to_graphite
OverviewGrinder to Graphite (g2g) is a tool that analyzes the logs from
your Grinder load tests, and sends the data into Graphite where it
can be visualized in a variety of ways.Realtime test data may be sent to Graphite while your Grinder run
is in progress, or it may be sent to Graphite after your test is
completed.Once the data is in Graphite you have a great amount of flexibility
in the types of reports and visualizations you want to generate.Who should use g2g?g2g may be a good match for you if any of the following are
true:You have access to a Graphite setup already, or you don’t
mind installing it.You sometimes do long-duration Grinder runs and you don’t
want to wait for the run to complete before you can see
charts of the incoming data.You want to integrate data from The Grinder with data from a
variety of other sources.  (OS metrics like CPU use, application
metrics like DB lookups per second, etc.)DocumentationComplete documentation and example graphs can be found athttps://grinder_to_graphite.readthedocs.org/en/latest/Installationg2g is installed from the command line.  Get pip, then runpip install grinder_to_graphiteSourceThe Grinder to Graphite sources are hosted on bitbucket.https://bitbucket.org/travis_bear/grinder_to_graphite
Package: grinmw
grinmw.pyGrin is a privacy-preserving digital currency built openly by developers distributed all over the world. Checkgrin.mwto know more!This module provides Python wrappers forGrin Wallet API V3Grin Node API V2Install withpip install grinmwIf you need help please check how to reach ourcommunity.ExamplesUsing the Node V2 API to access the locally running Grin node.fromgrinmw.node_v2importNodeV2importpprintfrompathlibimportPathhome=str(Path.home())pp=pprint.PrettyPrinter(indent=4)owner_api_url='http://localhost:3413/v2/owner'# change to your grin owner_api secret fileowner_api_sercet_file=os.path.join(home,'.grin/main/.api_secret')owner_api_user='grin'owner_api_password=open(owner_api_sercet_file).read().strip()foreign_api_url='http://localhost:3413/v2/foreign'# change to your grin owner_api sercret fileforeign_api_sercet_file=os.path.join(home,'.grin/main/.foreign_api_secret')foreign_api_user='grin'foreign_api_password=open(foreign_api_sercet_file).read().strip()node=NodeV2(foreign_api_url,foreign_api_user,foreign_api_password,owner_api_url,owner_api_user,owner_api_password)pp.pprint(node.get_status())pp.pprint(node.get_header(1036985))pp.pprint(node.get_kernel('096a7303ab9e3a68cf0b3d70d6ec61311efaf0f33f2ac251bff2a4da45908d3f15'))pp.pprint(node.get_kernel('08f0a2b7e3ddd0ccc60ac147e93f3e8b01ede591d0da08ba93333e3c73fd45c1cf'))Using the Wallet V3 API to access the locally running Grin wallet listener.fromgrinmw.wallet_v3importWalletV3importpprint,ospp=pprint.PrettyPrinter(indent=4)api_url='http://localhost:3420/v3/owner'# change to your grin owner_api sercret fileapi_sercet_file='/home/ubuntu/.grin/main/.owner_api_secret'api_user='grin'api_password=open(api_sercet_file).read().strip()wallet=WalletV3(api_url,api_user,api_password)wallet.init_secure_api()# change to you wallet passwordwallet_password='123'wallet.open_wallet(None,wallet_password)pp.pprint(wallet.node_height())pp.pprint(wallet.get_slatepack_address())# send to gate.iosend_args={'src_acct_name':None,'amount':int(2.67020546*1000000000),'minimum_confirmations':10,'max_outputs':500,'num_change_outputs':1,'selection_strategy_is_use_all':False,'target_slate_version':None,'payment_proof_recipient_address':'grin1n26np6apy07576qx6yz4qayuwxcpjvl87a2mjv3jpk6mnyz8y4vq65ahjm','ttl_blocks':None,'send_args':{"dest":'grin1n26np6apy07576qx6yz4qayuwxcpjvl87a2mjv3jpk6mnyz8y4vq65ahjm',"post_tx":True,"fluff":True,"skip_tor":False}}print(wallet.init_send_tx(send_args))
Package: grinpy
GrinPyA NetworkX extension for calculating graph invariants.What is it?GrinPy is an extension for NetworkX used for calculating graph invariants of
simple graphs.NP-hard invariants included are:Chromatic numberClique numberIndependence numberDomination numberTotal domination numberConnected domination numberIndependent domination numberPower domination numberZero forcing numberTotal zero forcing numberConnected zero forcing numberMinimum maximal matching numberGeneralizedkversions of almost all of the above invariantsOther invariants included are:Annihilation numberMatching numberResidueSlater numberSub-k-domination numberTopological indices, like the Randić and Zagreb indicesIn addition to the graph invariants listed above, we have included some
simple checks for structural properties of a graph:is_triangle_freeis_bull_freeis_claw_freeHow do I use it?Full documentation is available athttps://grinpy.rtfd.io.You can install GrinPy from the command line withpip:pip install grinpyHere is a sample of how to calculate the independence number:>>>importgrinpyasgp>>>G=gp.petersen_graph()>>>gp.independence_number(G)4GrinPy automatically importsNetworkXand provides all of the NetworkX classes and methods in the same interface.Why does it exist?The motivation for this project is to filter a database of graphs into an
ordered tree of subsets. This database will be used in an experimental automated
conjecturing program. In creating the required packages for this database, we
realized that a Python package for calculating graph invariants would be
useful for professional research and for graph theory education.LicenseReleased under the 3-Clause BSD license (seeLICENSE.txt):Copyright (C) 2017-2019 GrinPy Developers
David Amos <somacdivad@gmail.com>
Randy Davila <davilar@uhd.edu>
Package: griottes
Gustave Ronteix
Andrey Aristov
Author-email:aaristov@pasteur.frLicense: MIT
Project-URL: Source code, “https://github.com/BaroudLab/Griottes”,
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3 :: Only
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Requires-Python: >=3.8
License-File: LICENSE
Package: grip4-connector
GRIP4-connectorSimple donwloader for gadm border data.importgrip4EU=grip4.Region("Europe")DUTCH_ROADS=EU.get_roads("NLD")InstallingGrip4-connector is available on PyPI:python -m pip install grip4-connectorGrip4-connector is build for python 3.8+.Featuresget geopandas dataframe of region roadsget geopandas dataframe of country roads
Package: gripa
Welcome to GripaIntroductionGripa is a python package for time series anomaly detection. The name of Gripa is taken from Scandinavian languages, which means grab or catch or seize, and not meant as Flu in Spanish :smile:.Why Gripa?Gripa is light-weight.Try Gripa before you build LSTM or Transformer for your time series anomaly detection.Gripa is accurate.Gripa has two available algorithms that perform very well in detecting anomalies on your time series data.Gripa is comprehensive.Gripa can detect three types of anomaly: global anomaly, contextual anomaly, and level-shift.Quick StartInstallationPython 3.9or higher is required.python-mpipinstallgripaUsage# Load datafromgripaimportGripadetector=Gripa()anomalies=detector.fit_predict(data)API ReferenceThere is only one module,gripa.Gripa, that can be used for detecting anomalies in time series.classgripa.Gripa(window_size=11, algorithm="hpf", threshold=3)Parameterswindow_size:int or float, default=11algorithm:{"hpf", "ssa"}, default="hpf"threshold:float, default=3Attributesanomaly_score: score for labelling anomalyMethodsfit(X): train the Gripa model, which can generate attributeanomaly_scorefit_predict(X): train and generate anomaly labels (TrueorFalse)ContactHamid Dimyati -hamid.dimyati@outlook.com
Package: gripe
gripeOpinionated extensions for the `grip` utility.Thegrip utilityprovides rendering/serving local markdown files written in github-flavored markdown.  Gripe extends it, allowing for serving more types of local files, as well as intelligent management for multiple `grip` daemons.OverviewFeaturesSupport for Multiple ProjectsInstallationUsage (CLI)Listing ServersStarting and Stopping ServersUsage (API)Listing ServersStarting and Stopping ServersOverviewThegripelibrary provides extensions forgrip.Thegrip utilityprovides rendering/serving local markdown files written in github-flavored markdown.Gripe extends it, allowing for serving more types of local files, as well as intelligent management for multiplegripdaemons without thinking about server-port collisions.FeaturesSupport for Multiple ProjectsWorking with multiple projects simultaneously is supported.  This works by managing multiple daemons with a per-project port. SeeCLI Usagefor more information.InstallationSeepypifor available releases.$pipinstallgripeUsage (CLI)The gripe library publishes a small CLI tool.Listing Servers# or `gripe ls` or `python -mgripe ls`$gripelist{"local":[],"foreign":[]}Starting and Stopping Servers# or `python -mgripe start`$gripestart
INFOgripeTryingtoservefilesDEBUGgripeStartinggripeforthisproject..
DEBUGgripeUsedports:[]INFOgripestartingserverwithcommand:
INFOgripe'flask --app gripe:app run --port 6149 >> .tmp.gripe.log 2>&1 &'# startup example for a 2nd server over the same project: server start is NO-OP$gripestart
INFOgripeTryingtoservefilesINFOgripe1copiesofgripearealreadystartedINFOgripegripe@pid`10059`isalreadyservingthisproject
INFOgripeSkippingstartup.# startup example for 2nd server over 2nd project: new port allocated automatically$gripestart
INFOgripetryingtoservefiles
INFOgripe1copiesofgripearealreadystarted
INFOgripeNogripesareservingthisproject.
DEBUGgripeStartinggripeforthisproject..
DEBUGgripeUsedports:[6149]DEBUGgripeserverport@6149,usingnextavailable@6150INFOgripestartingserverwithcommand:
INFOgripe'flask --app gripe:app run --port 6150 >> .tmp.gripe.log 2>&1 &'$gripestop
INFOgripegripe@{'pid':10059,'cwd':'...','port':6149}startedhere
INFOgripekillingit..Usage (API)Listing Servers>>>importgripe>>>gripe.list(){"local": [], "foreign": []}Starting and Stopping Servers>>>importgripe>>>servers=gripe.start();print(servers){ "local": [{ "pid": 93867,"cwd": "...","port": 6149 }],"foreign": []}>>>gripe.stop(grips=servers['local']){"killed":[ { "pid": 93867,"cwd": "...","port": 6149 } ]}
Package: grip-intros
GRIP Intros API - Python SDK( Unofficial )CompatibilityRequires python 3.3+Installationpip install grip-introsBasic UsageFirst of all create a client instance, supplying your api tokenfrom grip_intros.client import GRIPClient
client = GRIPClient(api_key=<your api key>, test_mode=True)Get a list of containersIn [3]: containers = client.list_containers()
In [4]: containers
Out[4]: [<grip_intros.container.Container at 0x5cc7b70>, <grip_intros.container.Container at 0x4ef5330>]Create a containerIn [5]: data = { "name": "My Test Container", "description": "Test" }

In [6]: container = client.create_container(data)

In [7]: container
Out[7]: <grip_intros.container.Container at 0x7292370>

In [8]: vars(container)
Out[8]:
{'active': 1,
 'application_id': 41,
 'branch_url': None,
 'color': None,
 'connections_count': 0,
 'date_active': None,
 'date_created': 1515512190,
 'date_updated': None,
 'description': 'Test',
...}List ThingsIn [11]: things = client.get_things(container_id=containers[1].id)

In [12]: things
Out[12]:
[<grip_intros.thing.Thing at 0x6fd7cb0>,
 <grip_intros.thing.Thing at 0x6fc67f0>,
 <grip_intros.thing.Thing at 0x6fc64d0>,
 <grip_intros.thing.Thing at 0x6fc66f0>,
 <grip_intros.thing.Thing at 0x6fc6650>,
 <grip_intros.thing.Thing at 0x6fc6df0>,
 <grip_intros.thing.Thing at 0x6fc6dd0>,
 <grip_intros.thing.Thing at 0x6fc6630>,
 <grip_intros.thing.Thing at 0x6fc65f0> ...
 ]Create a ThingIn [13]: data = { "name": "Test", "email": "test12345@example.com" }

In [14]: thing = client.create_thing(data)

In [15]: thing
Out[15]: <grip_intros.thing.Thing at 0x707fd90>

In [16]: vars(thing)
Out[16]: {'id': 190176, 'uri': '/1/thing/190176'}Fetch a ThingIn [17]: thing = client.get_thing(thing.id)

In [18]: vars(thing)
Out[18]:
{'active': 1,
 'application_id': 41,
 'can_meet': 1,
 'can_swipe': 1,
 'categories': [],
 'categories_ids': [],
 'company_name': None,
 'current_position': {},
 'date_created': 1515512531,
 'date_updated': None,
 'email': 'test12345@example.com',
 'first_name': None,
 'gps_lat': None,
 ...
 }More to follow....