Saravanan666/pypi-org huggingface dataset:
Package: giant-people
Giant PeopleA re-usable package which can be used in any project that requires a genericPeopleapp.This will include the basic formatting and functionality such as model creation via the admin. The package also includes a cms plugin which allows a client to add a select number of people to a page and order them via a "drag and drop", provided bydjango-admin-sortable2.InstallationTo install with the package manager, run:$ poetry add giant-peopleYou should then add"people", "easy_thumbnails" and "filer"to theINSTALLED_APPSin your settings file.
The detail pages in this app use plugins which are not contained within this app. It is recommended that you include a set of plugins in your project, or use thegiant-pluginsapp.In order to rundjango-admincommands you will need to set theDJANGO_SETTINGS_MODULEby running$ export DJANGO_SETTINGS_MODULE=settingsConfigurationThis application exposes the following settings:PEOPLE_ADMIN_LIST_DISPLAYis the field list for the admin index. This must be a list.PEOPLE_ADMIN_SEARCH_FIELDSis the fields that can be searched against in the admin. This must be a list.PEOPLE_ADMIN_FIELDSETSallows the user to define the admin fieldset. This must be a list of two-tuples.PEOPLE_ADMIN_READONLY_FIELDSallows the user to configure readonly fields in the admin. This must be a list.Preparing for releaseIn order to prep the package for a new release on TestPyPi and PyPi there is one key thing that you need to do. You need to update the version number in thepyproject.toml.
This is so that the package can be published without running into version number conflicts. The version numbering must also follow the Semantic Version rules which can be found herehttps://semver.org/.PublishingPublishing a package with poetry is incredibly easy. Once you have checked that the version number has been updated (not the same as a previous version) then you only need to run two commands.$poetry buildwill package the project up for you into a way that can be published.$poetry publishwill publish the package to PyPi. You will need to enter the username and password for the account which can be found in the company password manager
Package: giant-redirect-import
Giant Redirect ImportA re-usable package which can be used in any project that requires a Redirect import via a CSV file.This will include a basic form to upload a CSV file in the standardRedirectapp supplied via django.InstallationTo install with the package manager, run:$ poetry add giant-redirect-importYou should then add"giant_redirect_import"to theINSTALLED_APPSin your settings file, this MUST be directly abovedjango.contrib.redirects.Inbase.pythere should also be aREDIRECT_IMPORT_DEFAULT_SITE_ID.ConfigurationThis application exposes the following settings:REDIRECT_IMPORT_DEFAULT_SITE_IDis the default site id used when importing and creating the redirects, this is usually the same as the SITE_ID.Preparing for releaseIn order to prep the package for a new release on TestPyPi and PyPi there is one key thing that you need to do. You need to update the version number in thepyproject.toml.
This is so that the package can be published without running into version number conflicts. The version numbering must also follow the Semantic Version rules which can be found herehttps://semver.org/.PublishingPublishing a package with poetry is incredibly easy. Once you have checked that the version number has been updated (not the same as a previous version) then you only need to run two commands.$ `poetry build`will package the project up for you into a way that can be published.$ `poetry publish`will publish the package to PyPi. You will need to enter the username and password for the account which can be found in the company password manager
Package: giants
giantsBasic machine learning optimization support, developed to identify big trees.Documentation:the.forestobservatory.com/giantsSource code:forestobservatory/giantsIntroductiongiantsis a simple package that provides python support for tuningsklearnmodels via hyperparameter searches. There are a series of pre-defined configurations and hyperparameter grids defined for a series of models, which should be fairly easy to extend as needed.It was originally developed for theBig Trees projectbut we found it useful enough to clean it up and publish it as a standalone package for easy re-use.InstallpipinstallgiantsDeveloped by
Package: giant-social-links
giant-social-linksA small reuseable django app that allows social media links to be added via the admin page of your django site.This will include the basic formatting and functionality such as model creation via the admin.Supported Django versions:Django 2.2, 3.2Supported django CMS versions:django CMS 3.8, 3.9Installation and set upIn the INSTALLED_APPS of your settings file add "giant_social_links" and below "cms" ensure "easy_thumbnails" and "filer" are present. It is also required that you use the giant-plugins & giant-mixins apps.A context processor is given by default so your Social links can be accessed anywhere on the site by rendering the template variable:{{ social_media_links }}Which will only show the enabled links. Feel free to override this with a custom context processor.Local developmentGetting setupTo get started with local development of this library, you will need access to poetry (or another venv manager). You can set up a virtual environment with poetry by running:$ poetry shellNote: You can update which version of python poetry will use for the virtualenv by using:$ poetry env use 3.xand install all the required dependencies (seen in the pyproject.toml file) with:$ poetry installManagement commandsAs the library does not come with a manage.py file we need to use django-admin instead. However, we will need to set our DJANGO_SETTINGS_MODULE file in the environment. You can do this with:$ export DJANGO_SETTINGS_MODULE=settingsFrom here you can run all the standard Django management commands such as django-admin makemigrations.
TestingThis library uses Pytest in order to run its tests. You can do this (inside the shell) by running:$ pytest -vwhere -v is to run in verbose mode which, while not necessary, will show which tests errored/failed/passed a bit more clearly.
Preparing for releaseIn order to prep the package for a new release on TestPyPi and PyPi there is one key thing that you need to do. You need to update the version number in the pyproject.toml. This is so that the package can be published without running into version number conflicts. The version numbering must also follow the Semantic Version rules which can be found herehttps://semver.org/.PublishingPublishing a package with poetry is incredibly easy. Once you have checked that the version number has been updated (not the same as a previous version) then you only need to run two commands.$ `poetry build`will package the project up for you into a way that can be published.$ `poetry publish`will publish the package to PyPi. You will need to enter the company username (Giant-Digital) and password for the account which can be found in the company password manager
Package: giant-utils
Giant UtilsA re-usable package which can be used in any django project that allows small common use functions such as an email with text and/or html templates to be sent.Other functionality includes a format_bytes method that takes a byte size of file and converts it to a human-readable number with the appropriate Byte suffix (useful for download files).Also includes a rich text field that can be used in various plugins where the admin may want to insert links or custom html.InstallationTo install with the package manager, run:$ poetry add giant-utilsYou should then add "giant_utils" to theINSTALLED_APPSin your project's settings file.  Then wherever you want to implement the function you can add the following import statements...from giant_utils.sender import send_email_from_template
from giant_utils.format_bytes import format_bytes
from giant_utils.fields import RichTextFieldRich Text FieldThis field can be customised by adding your own WYSIWYG_CONFIG variable to your project's settings. Otherwise it will fallback to the default below...DEFAULT_WYSIWYG_CONFIG = {
    "lang": "en",
    "minHeight": "300px",
    "buttons": "html | format | undo redo | bold italic | ul ol | link | sub sup".split(),
    "formatting": ["h1", "h2", "h3", "p"],
    "linkTitle": True,
    "linkNewTab": True,
    "structure": True,
    "removeNewLines": True,
    "pasteImages": False,
    "tabAsSpaces": 4,
    "plugins": ["table"],
}Pre-requisitesThe minimum package dependencies for this project are as follows...Django 4.0python 3.11Preparing for releaseIn order to prep the package for a new release on TestPyPi and PyPi there is one key thing that you need to do. You need to update the version number in thepyproject.toml.
This is so that the package can be published without running into version number conflicts. The version numbering must also follow the Semantic Version rules which can be found herehttps://semver.org/.PublishingPublishing a package with poetry is incredibly easy. Once you have checked that the version number has been updated (not the same as a previous version) then you only need to run two commands.$ `poetry build`will package the project up for you into a way that can be published.$ `poetry publish`will publish the package to PyPi. You will need to enter the username and password for the account which can be found in the company password manager
Package: giaola-xml-delta
===========delta 11888===========.. image:: https://pyup.io/repos/github/dimkl/giaola_xml_delta/shield.svg:target: https://pyup.io/repos/github/dimkl/giaola_xml_delta/:alt: Updates11888 delta app for das adminFeatures--------* TODOCredits---------This package was created with Cookiecutter_ and the `audreyr/cookiecutter-pypackage`_ project template... _Cookiecutter: https://github.com/audreyr/cookiecutter.. _`audreyr/cookiecutter-pypackage`: https://github.com/audreyr/cookiecutter-pypackageCreate table Section# create database using SQL`CREATE DATABASE delta;`# create table```>>>>>> from xml_delta import settings, models>>> from sqlalchemy import create_engine>>> engine = create_engine(settings.STORAGE_DATABASE_URL, echo=True)>>> from giaola_xml_delta import settings>>> from sqlalchemy import create_engine>>> engine = create_engine(settings.STORAGE_DATABASE_URL, echo=True)>>> from xml_delta import settings>>> from sqlalchemy import create_engine>>> engine = create_engine(settings.STORAGE_DATABASE_URL, echo=True)>>> from giaola_xml_delta import settings>>> from sqlalchemy import create_engine>>> engine = create_engine(settings.STORAGE_DATABASE_URL, echo=True)>>> models.Base.metadata.create_all(engine)```# run package1. edit settings using .env file2. execute: ` python -m giaola_xml_delta.giaola_xml_delta <sample_data>`=======History=======0.1.0 (2017-08-07)------------------* First release on PyPI.
Package: giaola-xml-utils
Giaola XML UtilsXML utility functionsFree software: MIT licenseDocumentation:https://giaola-xml-utils.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2017-12-01)First release on PyPI.
Package: gias2
A Python library for tools used in musculoskeletal modelling. Includes
tools for parametric meshing, registration, image analysis, statistical
shape modelling, and 3-D visualisation using Mayavi.Optional dependenciesVTK and VTK Python bindings (for mesh processing)Mayavi (for 3-D visualisation, requires Numpy, VTK, wxPython,
configobj)PyCSG (for generating constructive solids)pydicom (for reading DICOM images)Cython (speeds up active shape model and random forest segmentation)matplotlib for some inbuilt plotting functionsInstallationLinuxIf you would like to use in-built visualisation modules, first
install Mayavi for you distribution, else you can skip this step.Install VTK and VTK python bindings (e.g. through your package
manager). VTK 5.10 is the most stable in my experience with
Mayavi.Install mayavi through your package manager (e.g. sudo apt-get
install mayavi2) or pip (e.g. pip install –user mayavi)Download thewheelandpip install --user [path/to/wheel]WindowsThe most painless way to install the python dependencies required by
GIAS2 is to install the umbrella packageAnaconda.If you would like to use in-built visualisation modules, install
Mayavi. In you installed Anaconda, from the Anaconda commandline,conda install mayaviDownload the wheel and from the Anaconda commandlinepip install --user [path/to/wheel]ExamplesExample of some the capabilities of GIAS2 can be found in the
gias2/examples/ directory. We are working to add more examples.TutorialsUsing GIAS2 with MAP Client for lower limb model
generationUsing GIAS2 for statistical shape
modellingLicenseGIAS2 is under theMozilla Public license
2.0.
Package: gias3
A Python library for tools used in musculoskeletal modelling. Includes
tools for parametric meshing, registration, image analysis, statistical
shape modelling, and 3-D visualisation using Mayavi.ModulesThis meta-package includes the following modules:gias3.commongias3.fieldworkgias3.registrationgias3.learninggias3.image-analysisgias3.meshgias3.applications (optional)gias3.examples (optional)gias3.io (optional)gias3.testing (optional)gias3.visualisation (optional)gias3.mapclientpluginutilities (optional)gias3.musculoskeletal (optional - requires: OpenSIM)SeeInstalling optional modulesfor more information.Optional dependenciesVTK and VTK Python bindings (for mesh processing)Mayavi (for 3-D visualisation, requires Numpy, VTK, wxPython,
configobj)PyCSG (for generating constructive solids)pydicom (for reading DICOM images)Cython (speeds up active shape model and random forest segmentation)matplotlib for some inbuilt plotting functionsOpenSIM (required for gias3.musculoskeletal)InstallationLinuxIf you would like to use in-built visualisation modules, first
install Mayavi for your distribution, else you can skip this step.Install VTK and VTK python bindings (e.g., through your package
manager). VTK 5.10 is the most stable in my experience with
Mayavi.Install mayavi through your package manager (e.g.sudo apt-get
install mayavi2) or pip (e.g.,pip install –user mayavi)If you would like to use the GIAS3 Musculoskeletal module, you must
first install OpenSIM to your Python scripting environment. Otherwise,
you may skip this step. SeeInstalling OpenSIMfor more information.Install GIAS3pip install gias3WindowsIf you would like to use in-built visualisation modules, first
install Mayavi, else you can skip this step.If you are using Anaconda to manage your Python environment,
use conda to install Mayavi (e.g.,conda install mayavi),
otherwise, use pip (e.g.,pip install mayavi).If you would like to use the GIAS3 Musculoskeletal module, you must
first install OpenSIM to your Python scripting environment. Otherwise,
you may skip this step. SeeInstalling OpenSIMfor more information.Install GIAS3pip install gias3Installing optional modulesOptional GIAS3 modules can be included in the installation by passing the
corresponding keywords topip:apps= gias3.applicationsexamples= gias3.examplestests= gias3.testingvis= gias3.visualisationio= gias3.iomapclient= gias3.mapclientpluginutilitiesmusculoskeletal= gias3.musculoskeletalFor example, if you want to include the modulesgias3.applicationsandgias3.visualisationin addition to the default modules, use the command,pip install gias3[apps,vis]Installing OpenSIMTo be able to make use of the GIAS3 Musculoskeletal module, the user must
first install OpenSIM to their Python scripting environment.First, download OpenSIM fromthispage.Then, follow the instructionshereto install OpenSIM to your Python scripting environment.TutorialsUsing GIAS3 with MAP Client for lower limb model
generationUsing GIAS3 for statistical shape
modellingLicenseGIAS3 is under theMozilla Public license
2.0.
Package: gibberish
Thegibberishmodule let’s you generate random, pronounceable pseudo-words. It started life as ananswer on StackOverflowabout password generators , but it’s also a fun way to coin words or just spark some lexical creativity.Usagegibberishcreates pseudo-words which consist of one consonant-vowel-consonant syllable that sounds like it could be English. Sometimes it spits out real words; most of the time not:>>> from gibberish import Gibberish
>>> gib = Gibberish()
>>> gib.generate_word()
'zept'
>>> gib.generate_word(start_vowel=True)
'ientz'
>>> gib.generate_word(end_vowel=True)
'twae'
>>> gib.generate_words(3)
['sqiounn', 'nuil', 'hydrieucks']It also works as a console script:~$ gibberish 6
strit druf doct vel dosk flomp
~$ gibberish
brank
~$ gibberish 1 -l large
fabaduk
~$ gibberish 2 -l medium
voskot koontanInstallationTo install thegibberishmodule and console script globally, clone this repository and run:~$ python setup.py installUpdates(2017.5.11)Analyze the components from CMUdict (nltk.corpus.cmudict) entries.Usesecretsmodule if Python version 3.6 or later.ContributionsPlease help edit entry thegibberish/database/components.yamlas which of the characters is an initial consonant, final consonants, or vowels is opinionated.
Package: gibberish-detector
Gibberish DetectorThis is based offhttps://github.com/rrenaud/Gibberish-Detector, and adapted so that it is a
Python3 module.ExamplesQuickstart:$gibberish-detectortrainexamples/big.txt>big.model
$gibberish-detectordetect--modelbig.model--string"ertrjiloifdfyyoiu"TrueTraining Large Corpuses:$gibberish-detectortrain$(lsexamples)>generic.modelInteractive Detection:$gibberish-detectordetect--modelbig.model--interactive
Enteringinteractivemode.Pressctrl+dtoquit.
Inputtext:superman
False(2.375)Inputtext:ertrjiloifdfyyoiu
True(4.154)Installationpip install gibberish-detectorUsage$ gibberish-detector -h
usage: gibberish-detector [-h] [--version] {train,detect} ...

positional arguments:
  {train,detect}
    train         Trains a model to be used for gibberish detection.
    detect        Uses a trained model to identify gibberish strings.

optional arguments:
  -h, --help      show this help message and exit
  --version       Display version information.You can also use this as an imported module:>>>fromgibberish_detectorimportdetector>>>Detector=detector.create_from_model('big.model')>>>print(Detector.is_gibberish('ertrjiloifdfyyoiu'))True
Package: gibberishpy
gibberishpygibberishpy is a Python-based application designed to analyze and identify gibberish in a given string. The application leverages the principles of Markov Chains, a mathematical system that undergoes transitions from one state to other on a state space, to calculate both additive and multiplicative probabilities. gibberishpy allow users to build their own model with custom txt file.Usage ExamplesBuild Modelfrom gibberishpy.scanner import GibberishScanner


if __name__ == "__main__":
    scanner = GibberishScanner()
    scanner.build_model(corpus_path="path/to/corpus.txt", n_gram_size=2)
    scanner.save_model("transition_matrix_2d.tm", encoding="utf-8")Scan Gibberishfrom gibberishpy.scanner import GibberishScanner


if __name__ == "__main__":
    scanner = GibberishScanner()
    scanner.load_model(path="transition_matrix_2d.tm")
    additive_cum_proba, multiplicative_cum_proba = scanner.scan("ldfjgnkdfjnd")
    print(additive_cum_proba)
    print(multiplicative_cum_proba)

    # 0.00022810218978102192
    # 0.0
Package: gibbon
gibbonDescriptionOrganize the files in your filesystem according to their attributes.InstallationWithPythoninstalled, simply run the following command to add the package to your project.python-mpipinstallgibbonUsageThe following is an example usage of the package:fromgibbonimportTreewithTree("/path/to/root/folder/",glob="**/*.txt")astree:tree.flatten()Feel free tocheck out the docsfor more information.LicenseThis software is released under the terms ofMIT license.
Package: gibbs
gibbsScale your ML workers asynchronously across processes and machinesDescription•Install•Usage•FAQ•ContributeDocumentationDescriptiongibbsis a python package that helps you scale your ML workers (or any python code) across processes and machines, asynchronously.gibbsis :⚡️ Highly performant🔀 Asynchronous🐥 Easy-to-useInstallInstallgibbsby running :pip install gibbsUsageAfter defining your awesome model :importtimeclassMyAwesomeModel:def__init__(self,wait_time=0.25):super().__init__()self.w=wait_timedef__call__(self,x):time.sleep(self.w)returnx**2You can simply start a few workers serving the model :fromgibbsimportWorkerfor_inrange(4):Worker(MyAwesomeModel).start()And send requests through the Hub :fromgibbsimportHubhub=Hub()# In an async functionawaithub.request(34)And that's it !Make sure to check thedocumentationfor a more detailed explanation.Or you can run some examples from theexamples/folder.FAQ❓Howgibbsworks ?gibbssimply run your model code in separate processes, and send requests to the right process to ensure requests are treated in parallel.gibbsuses a modified form ofthe Paranoid Pirate Pattern from the zmq guide.❓Why the name "gibbs" ?Joshamee Gibbs is the devoted first mate of Captain Jack Sparrow.Since we are using the Paranoid Pirate Pattern, we needed a pirate name !ContributeTo contribute, install the package locally, create your own branch, add your code (and tests, and documentation), and open a PR !Pre-commit hooksPre-commit hooks are set to check the code added whenever you commit something.If you never ran the hooks before, install it with :pre-commitinstallThen you can just try to commit your code. If you code does not meet the quality required by linters, it will not be committed. You can just fix your code and try to commit again !You can manually run the pre-commit hooks with :pre-commitrun--all-filesTestsWhen you contribute, you need to make sure all the unit-tests pass. You should also add tests if necessary !You can run the tests with :pytestPre-commit hooks will not run the tests, but it will automatically update the coverage badge !DocumentationThe documentation should be kept up-to-date. You can visualize the documentation locally by running :mkdocsserve
Package: gibbs-sampler
Gibbs_SamplerThis program runs the Gibbs Sampler algorithm for
de novo motif discovery. Given a set of sequences, the program
will calculate the most likely motif instance as well as
the position weight matrix and position specific scoring matrix
(the log2 normalized frequency scores).The input sequence file should be provided in fasta format. Output is written to the console.
A eps file containing the weblogo of the motif is also created.
#Getting Started
##Prerequisites
Python 3.8 or later is required.
##Installation
The program can be installed with pip by running the following command:$pipinstallgibbs_samplerUsageTo run, simply call gibbs_sampler from the command line along with
the path to the sequence file and expected width of the motif.$gibbs_sampler<primarysequencefile><width>Optional arguments for the title of the weblogo file and number of
iterations of the sampler can be specified using the -t and -n flags respectively.Licensegibbs_samplerwas created by Monty Python. It is licensed under the terms of the CC0 v1.0 Universal license.CreditsThank you to Professor Hendrix for teaching me how to use python to investigate biologically relevant questions.