Saravanan666/pypi-org huggingface dataset:
Package: gl-webhooks
gl-webhooksGL Webhooks is a project that provides GitLab functionalities via webhook endpoints.It is a WSGI application written with theFlaskframework withconnexionon top of it. It can be served viaGunicornwith a helper script.Configuration fileA template configuration file can be found inconf/gl-webhooks.yml.Configuration will be taken, in order, from command line then configuration file.Development environmentSetup# pip and virtual env are required to be installed system wideapt-getinstallpython3-pippython3-venv# create a virtualenv inside a folder called '.venv'python3-mvenv.venvsource.venv/bin/activate

pip3install-rrequirements-dev.txt# Run the flask server:./bin/gl-webhooks-devProductionYou can run a production server as a Gunicorn WSGI application with a helper script:pip3install-rrequirements.txt

./bin/gl-webhooksLicenseThis project is licensed under the MIT License - see theLICENSEfile for details.LocationsGitLab:https://gitlab.com/jlecomte/python/gl-webhooksPyPi:https://pypi.org/project/gl-webhooks
Package: glycomesite.policy
IntroductionThis is the “policy” product for the public portal of the Alliance of
Glycobiologists for Detection of Cancer and Cancer Risk, or Glycans.  This
product specifies no custom content types or look-and-feel but instead
specifies minimum policy settings and orchestrates all other dependent
components.  To turn a Plone site into the Glycans site, just install this
component.Changelog0.0.0 - UnreleasedInitial release
Package: glycosylator
A Python framework for the rapid modeling of glycansGlycosylator is a Python framework for the identification, modeling and
modification of glycans. Glycosylator can build atomic models of glycans and can glycosylate proteins and membranes. Glycosylator can perform conformational optimization to minimize clashes in glycosylated structures or to sample alternative conformations for individual glycans. Glycosylator supports a variety of file-formats and can work hand in hand with other libraries such as RDKit to faciliate research workflows.Building a glycan from IUPACGenerating an atomic model from a IUPAC glycan string can be as easy as:importglycosylatorasgl# this is GlyCosmos entry G09568JTiupac="Gal(b1-4)GlcNAc(b1-2)[Gal(b1-4)GlcNAc(b1-4)]Man(a1-3)[Gal(b1-4)GlcNAc(b1-2)[Gal(b1-4)GlcNAc(b1-6)]Man(a1-6)]Man(b1-4)GlcNAc(b1-4)GlcNAc"glycan=gl.glycan(iupac)glycan.to_pdb("my_glycan.pdb")glycan.show3d()Note: This visualization was hand-made in ChimeraX from the PDB file, so the actual output of show3d will not be quite this pretty, but it will be interactive...Glycosylating a proteinTo glycosylate a protein we can use a simple snippet like the one below. Check out the tutorials in the documentation for more info on glycosylation and how to optimize a glycosylated protein afterward.importglycosylatorasgl# get some protein scaffoldprotein=gl.Scaffold.from_pdb("my_protein.pdb")# get some glycan (maybe we already have one as a PDB file)glycan=gl.Glycan.from_pdb("my_glycan.pdb")# glycosylate the protein at N-glycosylation sitesglycoprotein=gl.glycosylate(protein,glycan,sequon="N-linked")glycoprotein.to_pdb("my_glycoprotein.pdb")ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.LicenseMIT
Package: glyf
GlyfGlyfis a library for easy plotting of multiple images and graphs in Python. It provides a simple interface that allows flexible plots parametrization.It supportsnumpyarrays as inputs and usesmatplotlibto produce output visualizations.Basic usageImport is as ordinary as this.fromglyfimportplotPlot single image.plot(image)Plot image and mask overlayed.plot([image,mask])Plot image and mask side to side.plot([image,mask],combine='separate')Advanced usageSeetutorials.Installationpip3 install glyfAcknowledgmentsThe code in this repository is based onplottermodule ofbatchflowframework developed byData Analysis Centerteam under Apache 2.0 license. The main focus of this project is adding new features without needing to keep backward compatibility with API of the original project.
Package: glyles
GlyLESA tool to convert IUPAC representation of Glycans into SMILES representation. This repo is still in the development
phase; so, feel free to report any errors or issues. The code is available ongithuband the documentation can be found onReadTheDocs.Specification and (current) LimitationsThe exact specification we're referring to when talking about "IUPAC representations of glycan" or "IUPAC-condensed",
is given in the "Notes" section of thiswebsite. But as this package
is still in the development phase, not everything of the specification is implemented yet (especially not all side
chains you can attach to monomers). The structure of the glycan can be represented as a tree of the monosaccharides
with maximal branching factor 4, i.e., each monomer in the glycan has at most 4 children.InstallationSo far, this package can only be downloaded from the python package index. So the installation withpipis very easy.
Just typepipinstallglylesand you're ready to use it as described below. Usepipinstall--upgradeglylesto upgrade the glyles package to the most recent version.Basic UsageAs a Python PackageConvert the IUPAC into a SMILES representation using the handyconvertmethodfromglylesimportconvertconvert(glycan="Man(a1-2)Man",output_file="./test.txt")You can also use theconvert_generatormethod to get a generator for all SMILES:fromglylesimportconvert_generatorforsmilesinconvert_generator(glycan_list=["Man(a1-2)Man a","Man(a1-2)Man b"]):print(smiles)For more examples of how to use this package, please see the notebooks in theexamplesfolder and checkout the documentation onReadTheDocs.In the CommandlineAs of version 0.5.9, there is a commandline interface to GlyLES which is automatically installed when installing GlyLES
through pip. The CLI is open for one or multiple IUPAC inputs as individual arguments. Due to the syntax of the
IUPAC-condensed notation and the argument parsing in commandlines, the IUPAC strings must be given in quotes.glyles-i"Man(a1-2)Man"-otest_output.txt
glyles-i"Man(a1-2)Man""Fuc(a1-6)Glc"-otest_output.txtFile-input is also possible.glyles-iinput_file.txt-otest_output.txtProviding multiple files and IUPAC-condensed names is als supported.glyles-iinput_file1.txt"Man(a1-2)Man"input_file2.txtinput_file13.txt"Fuc(a1-6)Glc"-otest_output.txtNotation of glycansThere are multiple different notations for glycans in IUPAC. So, according to theSNGF specification,Man(a1-4)Gal,Mana1-4Gal, andMana4Galall describe the same disaccharide. This is also covered in this package as all three notations will be parsed into the
same tree of monosaccharides and result in the same SMILES string.This is also described more detailed in a section onReadTheDocs.PoetryTo develop this package, we use the poetry package manager (seeherefor detailed
instruction). It has basically the same functionality as conda but supports the package management better and also
supports distinguishing packages into those that are needed to use the package and those that are needed in the
development of the package. To enable others to work on this repository, we also publish the exact
specifications of our poetry environment.
Package: glyphoji
GlyphojiModernhieroglyphsin the terminal.>>>fromglyphojiimportglyph>>>print(f"This{glyph.burger}is a burger!")This🍔isaburger!Glyphojiis a friendly cross-platform emoji library that brings a touch of fun to your terminal experience! 🎉 With a collection of over 2,500 old + new emojis, your code can now smile, wink, and dance.
Adding visual flair to your code has never been this easy!😎ℹ️ Getting Started⬇️ Installation📦 PyPIGlyphoji can be installed from PyPI withpipby running the command:$ pip install glyphoji🚧 Dev from GitHubIntstalling the unreleased dev version of Glyphoji can also be done withpip:$ pip install git+https://github.com/rly0nheart/glyphoji.git@devThe unreleased versions might not be stable.📖 Code Examples😀 Available Glyphs/EmojisAll glyphs/emojis can be printed by accessing theglyphsattribute from theglyphinstance.>>>fromglyphojiimportglyph>>>print(glyph.glyphs)🥑:{'aliases':['avocado'],'description':'An avocado.'}🍆:{'aliases':['eggplant'],'description':'An eggplant.'}🥔:{'aliases':['potato'],'description':'A potato.'}🥕:{'aliases':['carrot'],'description':'A carrot.'}🌽:{'aliases':['ear_of_corn','corn','maize'],'description':'An ear of corn.'}🌶️:{'aliases':['hot_pepper'],'description':'A hot pepper.'}🫑:{'aliases':['bell_pepper'],'description':'A bell pepper.'}...🔍 Searching GlyphsGlyphoji also lets users search for a specific glyph, and returns all results that closely match with the query. The query can be the glyph name/alias or a description of the glyph.>>>fromglyphojiimportglyph>>>query="flying saucer">>>print(glyph.search(query))[closematchesto`flyingsaucer`]🛸:{'aliases':['flying_saucer','ufo','spaceship','spacecraft'],'description':'A flying saucer.'}📛 AliasesSome glyphs have aliases or alternate names that can also be used to return the glyph itself:>>>fromglyphojiimportglyph>>>print(f"This{glyph.hotdog}is a hot dog!")This🌭isahotdog!>>>print(f"This{glyph.hot_diggity_dog}is also a hot dog!")This🌭isalsoahotdog!>>>fromglyphojiimportglyph>>>print(f"The party was{glyph.fire}")Thepartywas🔥>>>print(f"The party was{glyph.lit}")Thepartywas🔥
Package: glyphs
glyphsExamplesSample response JSON from an API call looks as follows. Let's assume for the example that we keep a reference to that dictionary.my_json_dict={'expand':'schema,names','issues':[{'expand':'operations,versionedRepresentations,editmeta,changelog,renderedFields','fields':{'status':{'description':'','id':'10001','name':'Done','statusCategory':{'colorName':'green','id':3,'key':'done','name':'Done',}}},'id':'10022','key':'XXX-23'},{'expand':'operations,versionedRepresentations,editmeta,changelog,renderedFields','fields':{'status':{'description':'','id':'10001','name':'Done','statusCategory':{'colorName':'green','id':3,'key':'done','name':'Done',}}},'id':'10021','key':'XXX-22'},],'maxResults':50,'startAt':0,'total':17}How would you get thestatus&statusCategory'sidfor each item of the "issue"?issues=my_json_dict['issues']ifissues:# add a lot of code to check if the type returns worked for you# add a lot of code to handle exceptionsforissueinissues:status_name=issue['fields']['status']['name']# add a lot of code to check if the type returned works for you# add a lot of code to handle exceptions# add a code convert the data or have the rest of your code handle unpredictable returnsstatus_id=issue['fields']['status']['statusCategory']['id']# add a lot of code to check if the type returned works for you# add a lot of code to handle exceptions# add a code convert the data or have the rest of your code handle unpredictable returnsThis is the shortest you could possibly write it. Now you have to hope for the best from there, write a lot of
code to handle exception, data conversion etc.With Glyphs:fromglyphs.ro.ROGlyphimportROGlyphfromglyphs.utils.DictUtilsimportDictUtilsissues_glyph=ROGlyph('issues',r_translation_function=list,r_default_value=tuple())name_glyph=ROGlyph('fields>status>name',r_translation_function=unicode,)cat_id_glyph=ROGlyph('fields>statusCategory>id',r_translation_function=int,r_default_value=-1)issues=DictUtils.get(my_json_dict,issues_glyph)forissueinissues:status_name=DictUtils.get(my_json_dict,name_glyph)status_id=DictUtils.get(my_json_dict,cat_id_glyph)Similar code with a twist:we know that what we got is precisely what we wanted.simpler errors and missing data are automatically handled for us (with tasteful defaults)it also supportsfunctools.partialif we want to make our code shorterthe glyphs are infinitely shareable!! reuse and abuse!we can swapDictUtilswith a different util (any that you want) if the type ofmy_json_dictchanges
(in later versions of the code) and everything will still work as we intended.
Package: glyphspkg
glyphspkgConverter for GlyphsApp package to monolithic files.Glyphssupports two different file formats, both of
which are based on plist. One, using the suffix.glyphs, is a monolithic
file, the other, using the suffix.glyphspackage, is a special folder that
appears as one file on macOS.Thepackagevariant has advantages when used in SCM systems, but some
external tools only support the monolithic file format. That’s where this
converter tool comes in. It can be integrated into font build workflows to
convert package files before further processing.Installationglyphspkgis listed on PyPi, so you can install it via pip.Usageusage: glyphspkg [-h] [-o OUTPUT_PATH] glyphsfile [glyphsfile ...]

positional arguments:
  glyphsfile            Path to the glyphs file or package to be converted.

options:
  -h, --help            show this help message and exit
  -o OUTPUT_PATH, --output OUTPUT_PATH
                        Output path for converted files. If omitted, the file is saved next to the original.Known issuesOnly conversion from.glyphspackageto.glyphsis implemented at the moment.
Package: glyphviewer
AboutGlyphvieweris a web application that analyses web font files. This app will
parse any web font file provided as input, and will display its general information
(such as name and copyright details) to the user. Glyphviewer also provides a testbed
where users can enter text, and have it displayed using the font. Finally, this
application can display the characters supported by the font along with their Unicode
codepoints. A demonstration is availablehere.InstallationGlyphviewerand its dependencies can be installed via the command:pip install glyphviewerThe next stage is to add “glyphviewer” to your INSTALLED_APPS list in settings.py,
and add the desired URL in one of the urls.py files.The final stage is to populate the directory with fonts where you display your chosen font or fonts.
The Glyphviewer application comes with its own set of fonts adapted from theFree UCS Outline Fonts;
they have been converted to WOFF form for quicker download. These can be moved into the correct directory via the following shell command:python manage.py collectstaticThe font files wil then be moved into the {STATIC_ROOT}/glyphviewer/fonts/ directory, and the browser will
read the files from the {STATIC_URL}/glyphviewer/fonts/ folder.The HTML template files in this application have been redesigned to work with theMezzanineCMS. The redesign removed any explicit
references to particular stylesheets found with earlier versions.
The app (and the fonts) are released under aGNU general public license.If you wish to do any changes,
pop over to theGitHub repositoryfor the app.Versions0.1 (June 11th 2011) - Initial release.0.2 (June 28th 2013) - Added setup script to create a PyPI package. Removed bugs.0.3 (February 15th 2014) - Made compatible with Mezzanine and Bootstrap, changed styles for errors, now handles empty local directories.0.4 (January 16th 2016) - Now handles cases where remote fonts are inaccessible using CORS; removed the limitation that restricted characters to the BMP; added documentation for above.0.5 (March 31st 2017) - Updated to be compatible with Django 1.10. Now automatically install dependencies using pip.0.6 (March 18th 2018) - Add WOFF2 compatibility.0.7 (December 6th 2020) - Updated for Python 3 compatibility.0.8 (December 10th 2020) - Better representation of font header information as text; better use of urllib for Python 3.CopyrightTheGlyphviewerapp is copyright (c) 2011-2020Peter Murphy<peterkmurphy@gmail.com>.
Package: glypy
Glycobiology is the study of the biological functions, properties, and
structures of carbohydrate biomolecules, also calledglycans. These
large, tree-like molecules are complex, having a wide variety of
building blocks as well as modifications and substitutions on those
building blocks.glypyis a Python library providing code for reading, writing, and
manipulating glycan structures, glycan compositions, monosaccharides, and
their substituents. It also includes interfaces to popular glycan structure
databases,GlyTouCanandUnicarbKBusingSPARQLqueries and an RDF-object mapper.Example Use CasesTraverse structures using either canonical or residue-level rule
ordering.Operate on monosaccharide and substituents as nodes and bonds as
edges.Add, remove, and modify these structures to alter glycan properties.Identify substructures and motifs, classifying glycans.Evaluate structural similarities with one of several ordering and
comparator methods.Plot tree structures with MatPlotLib, rendering using a configurable
symbol nomenclature, such as SNFG, CFG, or IUPAC. Layout using vector
graphics for lossless scaling.Calculate the mass of a native or derivatized glycan.Generate glycosidic and cross ring cleavage fragments for a
collection of glycan structures for performing MS/MS database search.Perform substructure similarity searches with exact ordering or
topological comparison and exact or fuzzy per-residue matching to
classify a structure as an N-linked glycan.Annotate MS spectra with glycan structures, labeling which peaks
matched a database entry.Download all N-Glycans fromGlyTouCanFind all glycans in a list which contain a particular subtree, or
find common subtrees in a database of glycans, performing treelet
enrichment analysis.Synthesize all possible glycans using a set of enzymes starting from
a set of seed structures.CitingIf you useglypyin a publication please cite:Klein, J., & Zaia, J. (2019). glypy - An open source glycoinformatics library.
Journal of Proteome Research.https://doi.org/10.1021/acs.jproteome.9b00367
Package: glytrait
GlyTraitThis is a preliminary version of the glyTrait package.InstallationRequirementpython >= 3.10Using pipx (recommended)Install pipx following itsDocument.Clone the repository:gitclonehttps://github.com/fubin1999/glytrait.gitMove to the repository:cdglytraitInstall glyTrait with poetry:pipxinstall.Using poetryInstall poetry following itsDocument.Clone the repository:gitclonehttps://github.com/fubin1999/glytrait.gitMove to the repository:cdglytraitInstall glyTrait with poetry:poetryinstall
Package: gm2addon
Welcome to thegm2addontool, which creates a firefox addon from a
greasemonkey user script.gm2addonnot only generates the.XPI, but can also manage theupdate.rdffile so that updates
can be deployed easily as well.Thegm2addontool can be used on the command line directly with
many control options, or it can be embedded into other python scripts
by importing thegm2addonmodule.Please see the generated documents in the “doc” directory (for
downloaded packages) or online at <http://uberdev.org/gm2addon/>
for significantly more how-to documentation as well as an API
reference.
Package: gm2m-relations
gm2m_relationsTherest-framework-gm2m-relationslibrary provides read/write serialization fordjango-gm2mfield.RequirementsAny currently-supported combination ofrest-framework-generic-relations, Django REST Framework, Python, and Django.InstallationInstall usingpip:pipinstallgm2m-relationsAPI ReferenceGM2MSerializerserializes django generic many-to-many field. For a primer on generic many-to-many field, first see:https://github.com/tkhyn/django-gm2mLet's assume aPostmodel which has a generic m2m relationship with other arbitrary models:fromgm2mimportGM2MFieldclassPost(models.Model):text=models.SlugField()author=GM2MField()And the following two models, which may have associated authors:classUser(models.Model):name=models.CharField()classOrgan(models.Model):name=models.CharField()Now we define serializers for each model that may get associated with posts.classUserSerializer(serializers.ModelSerializer):classMeta:model=Userfields=('name',)classOragnSerializer(serializers.ModelSerializer):classMeta:model=Organfields=('name',)The model serializer for thePostmodel could look like this:fromgm2m_relations.serializersimportGM2MSerializerclassPostSerializer(serializers.ModelSerializer):"""A `Post` serializer with a `GM2MField` mapping all possiblemodels to their respective serializers."""author=GM2MSerializer({User:UserSerializer(),Organ:OragnSerializer(),},many=True,)classMeta:model=Postfields=('text','author')The JSON representation of aPostobject withtext='django'and its generic m2m field pointing toUserobject withname='Ali'would look like this:{"author":[{"name":"Ali",}],"text":"django"}Writing to generic many to many fieldThe abovePostSerializeris also writable. By default, aGenericRelatedFielditerates over its nested serializers and returns the value of the first serializer that is actually able to performto_internal_value()without any errors.post_serializer=PostSerializer(data={'text':'python','author':[{"name":"Ali",},],},)post_serializer.is_valid()post_serializer.save()If you feel that this default behavior doesn't suit your needs, implement your own way of decision-making.
Package: gma
PrefaceFor most scholars of geosciences or meteorology, data processing is a big project, which can take several hours or days of data processing. Without good tools or methods, it will be extremely difficult to analyze and research data with multiple time series (such as time series remote sensing data) and large-scale (such as nationwide), because data processing itself is very time-consuming and labor-intensive.In order to solve these problems, gma (Geographic and Meteorological Analysis) encapsulates the data processing process.Requiresgdal: >= 3.4.1pandas: >= 1.4.2numpy: >= 1.23.3scipy: >= 1.7.3psutil: >= 5.8.0tqdm: >= 4.64.1matplotlib: >= 3.5.2Included featuresClimate and meteorology(climet): e.g. SPEI, SPI, ET0, etc.Remote sensing indices(rsvi): e.g. NDVI, EVI, TVDI, etc.Mathematical operations(math): e.g. data smoothing, evaluation, filtering, stretching, enhancement transformations, etc.System interaction(osf): e.g. path retrieval, renaming, compression, etc.Spatial miscellany(smc): e.g. spatial distance calculation, area calculation, coordinate transformation, spatial interpolation, etc.Geographic formats(gft): e.g. creating and modifying raster/vector driven formats.Raster processing(rasp): e.g. raster mosaicking, cropping, resampling, reprojection, format conversion, data fusion, etc.Vector processing(vesp): e.g. vector clipping, erasing, intersection, merging, reprojection, etc.Coordinate reference system(crs): e.g. creating projections, ellipsoids, datum, etc.Map tools(map): e.g. raster and vector data visualization, generating north arrow, scale bar, defining coordinate systems, etc.ThanksThank you for giving me encouragement, classmates, colleagues and friends all the way. Because of your existence, we have more power to complete. We will not list the personnel here, but we still sincerely thank you.Due to the limited level, there will be more or less problems in the function. Looking forward to your feedback and corrections.More functions will be added later. We hope you can provide valuable comments.