Saravanan666/pypi-org huggingface dataset:
Package: gdctools
# gdctoolsPython and UNIX CLI utilities to simplify search and retrieval of open-access data from the [NIH/NCI Genomics Data Commons](https://gdc.cancer.gov/), and automate tasks that are common to most data-driven science projects.   For more information and examples see the [pictorial overview](https://docs.google.com/viewer?url=https://github.com/broadinstitute/gdctools/files/825892/GDCtools-overview.pdf), [Wiki pages](https://github.com/broadinstitute/gdctools/wiki) or [tests/Makefile](tests/Makefile).  To get started from a Unix command line, simply `pip install gdctools` or clone the repo and install:```%  git clone https://github.com/broadinstitute/gdctools%  cd gdctools%  make install```This should take only a minute or two, and may install [requests](http://docs.python-requests.org/en/master/), [fasteners](https://github.com/harlowja/fasteners) or [matplotlib](http://matplotlib.org/) dependencies.  *Note that if you are installing to a protected location you may need to preface the `make install` command with `sudo.`  After this you should be able to easily [mirror](https://github.com/broadinstitute/gdctools/wiki/GDC-Mirror) either [harmonized](https://gdc.cancer.gov/about-data/gdc-data-harmonization) or [legacy](https://gdc-portal.nci.nih.gov/legacy-archive) data directly from the command line```gdc_mirror --config tests/tcgaSmoketest.cfg```(this is what the `make test` target does), even for a single patient case```gdc_mirror --cases TCGA-EE-A3J8```or just one category of data for that patient```gdc_mirror --cases TCGA-EE-A3J8 --categories "Copy Number Variation"```or perform other operations such as seeing which NIH/NCI programs have exposed data for download```%  gdc_list programs["TCGA","TARGET"]```or what programs have submitted data (that may not be exposed yet)```%  gdc_list submission["CCLE","REBC","TCGA","TARGET","CGCI","CDDP","ALCHEMIST","GDC","Exceptional_Responders","UAT08","TRIO","CPTAC"]```After mirroring you may run [gdc_dice](https://github.com/broadinstitute/gdctools/wiki/GDC-Dicer) on the mirror tree, followed by [gdc_loadfile](https://github.com/broadinstitute/gdctools/wiki/Create-Loadfile) to generate a sample "freeze" list which identifies the data for loading into pipeline execution systems like Firehose or FireCloud.  Finally, if you have *matplotlib* and *R* installed you may also run the [gdc_report](https://github.com/broadinstitute/gdctools/wiki/Sample-reports) tool to generate an HTML samples report ([similar to this](http://gdac.broadinstitute.org/runs/sampleReports/latest/)) that provides an annotated description of the processed data; note that this tool will attempt to automatically install [Nozzle](https://confluence.broadinstitute.org/display/GDAC/Nozzle) if it is not detected within the R installation. As noted earlier, the [tests/Makefile](tests/Makefile) provides examples of using the dice, loadfile and report tools.  GDCtools has been verified to function properly with multiple Python2 and Python3 versions, and we are [grateful for the community contributions](https://github.com/broadinstitute/gdctools/commit/53be8ee4d720b502c2dbb1e110e7c20754331e3e) in support of this goal.
Package: gddecoder
gddecoderLib for work this Geometry Dash levelsStartfromgddecoderimport*levels=LocalLevels()If you need to work with a save file that is not in the standard pathlevels=LocalLevels("path/to/file/CCLocalLevels.dat")LocalLevelsis list of levels, to get the level, use thelevels.get_level()method or standard list syntaxlevels[n].level1=levels.get_level(10)level2=levels.get_level("first level")level3=level[10]levels[n]don't support levels names,level["first level"].Change levelsLevel isdict. To refer to a key in a level, you can use the name of the key that matches the name of the key in the game's save file, or use theLevelSettingsenum.level["k2"]="test level"level[LevelSettings.objects_count]=800Some programsPrint names of all levels:fromgddecoderimport*levels=LocalLevels()forlvlinlevels:print(lvl[LevelSettings.name])Counting the total number of jumps in levels:fromgddecoderimport*levels=LocalLevels()jumps=0forlvlinlevels:# test because the level may not have jumpsifLevelSettings.jumpsinlvl:jumps+=lvl[LevelSettings.jumps]print(jumps)EditorLevel has methodget_editor, it return Editor object.editor=level.get_editor()Editor object has attributeblocksandcolors. Other properties are stored as in a dictionary. UseEditorSettingsenum or game key.# set 2 player modeeditor[EditorSettings.two_player_mode]=True# get 20 block in levelblocks=editor.blocks[19]# get bg Colorcolor_bg=editor.colors[1000]BlocksBlocks are also dictionaries. UseBlockSettingsenum.block=editor.blocks[9]block[BlockSettings.x]=30block[BlockSettings.y]=15Add blockeditor.blocks.add(Block({BlockSettings.id:1,BlockSettings.x:15,BlockSettings.y:15,}))Block duplicationeditor.blocks.add(Block(editor.blocks[9]))Set groupsGroupsis set.block=editor.blocks[9]block[BlockSettings.groups]=Groups([1,2,10])block[BlockSettings.groups].add(14)block[BlockSettings.groups].pop(10)ColorsThe block stores only the color channel of the block as an int. To change a color, you need to change the corresponding color ineditor.colorsand then assign it to the block.SaveSave to standart path:level.set_editor(editor)levels.save()For other path:level.set_editor(editor)levels.save("other/path/file.dat")
Package: gddl
gddlDownload files from google drive with resuming capability.DESCRIPTIONThis program can be used for downloading files (including large files) from google drive using the command line. The program supports resuming which is lacking in most of the command line google drive downloaders.INSTALLATIONFrom a command line enter the command to install gddlpip install gddlYou need to have python 3 installed. gddl won't run on python 2.USES$gddl"https://drive.google.com/open?id=abcde12345"Note: Quotes are required for some urls.DEPENDENCYrequestsurllib3ACKNOWLEDGEMENTSgdown.plproject - for regular expression to extract file id form url.coursera-dlproject - for their simple and awesome native downloader.
Package: gddPy
gddPyDescriptionThis Python library is intended for agriculture professionals interested in calculating growing degree days (GDD). GDD is also known as heat units or thermal units.Installation and Initial UsageTo begin using the library, install it using one of the following commands based on your system and package management strategy:pipinstallgddPy
pip3installgddPy
poetryaddgddPyNext, here's a quick example of using the library:fromgddPyimportGDDgdd=GDD()gdd.min_temp=34gdd.max_temp=60gdd.threshold_low=40heat_units=gdd.calcDailyAverage()# should calculate to 7Detailed DescriptionThe library supports the following properties:PropertyDescriptionmin_templow temperature for the daymax_temphigh temperature for the daythreshold_lowbase threshold to begin accruingmin_temp_cutoffoptional limit for min_tempmax_temp_cutoffoptional limit for max_tempEach property may be set when creating a new GDD() instance as a dictionary propertyparams={"min_temp":34,"max_temp":60,"threshold_low":40}gdd=GDD(params)The following calculation methods are supported, each with a description of the formulaDailyAverageThe Daily Average method is the simplest approach to calculate GDD. The formula takes the average temperature for the day and subtracts the lower threshold from it^1.$\text{GDD} = \frac{T_{\text{max}} + T_{\text{min}}}{2} - TH_{\text{low}}$Baskerville-EminThe Baskerville-Emin method is a more complex approach to calculate GDD that is preferable in regions with larger temperature fluctuations^2.$\text{GDD} = \frac{w \cdot \sqrt{1 - \left(\theta\right)^2} - (TH_{\text{low}} - T_{\text{avg}}) \cdot \arccos\left(\theta\right)}{\pi}$where...$w =$ Half of the Daily Temperature Range$T_{\text{avg}} =$ Average Temperature$TH_{\text{low}} =$ Lower Threshold$\theta = \frac{TH_{\text{low}} - T_{\text{avg}}}{w}$Hourly UtilizationThe Hourly Utilization method is a more precise approach to calculate GDD that requires hourly temperature readings to determine the thermal accumulation for each hour individually.$\text{GDD} = \frac{\sum_{h=1}^{24} \max\left( T_{h} - TH_{\text{low}}, 0 \right)}{24}$Although the formula above assumes a whole day (24 hours) this library is able to calculate partial days by providing less than 24 temperature values tohourly_tempsgdd=GDD()gdd.threshold_low=34gdd.hourly_temps=[32,36,51,60,74,75,70,66,63,61]heat_units=gdd.calcHourlyUtilization()Using min_temp_cutoff and max_temp_cutoffTo usemin_temp_cutoffand/ormax_temp_cutoff, pass a dictionary to any calculation method setting flags toTrue.temperature_data={"min_temp":34,"max_temp":60,"min_temp_cutoff":35,"max_temp_cutoff":55,"threshold_low":40}gdd=GDD(temp_data)params={"cutoff_min_temp":True,"cutoff_max_temp":True}heat_units=gdd.calcDailyAverage(params)# equals 5Changelogv1.0.3 | January 30, 2024: AddedcalcHourlyUtilization()method, which requiresthreshold_lowandhourly_tempsto be set. Added two propertiesmin_temp_cutoffandmax_temp_cutoffthat can be used with any of the calculation methods by passinguse_min_cutoff = Trueoruse_max_cutoff = True
Package: gde
Graph Data Extractor (GDE)GDE is a simple tool that lets you overlay axes on a raster image (e.g. a jpeg from a figure), click on some data points, and then extract them as CSV.
More sophisticated alternatives are available!GDE is maintained ongithub.It was originally part ofMyokit, but is now a separate project.Installpip install gdeUsageTo run, simply typegde, orpython3 -m gde.To load a file, usegde gui file.gde.To install shortcuts and register file types:gde iconsFor more options, trygde --help
Package: gdecomp
gdecomp: python binding of C++ signal gaussian decomposition.This package aims at decomposing a signal (1D numpy array) into a sum of gaussian,
typically used in full waveform lidar analysis.
It is used in particular to process lidar simulations produced withpytools4dart.
This code is inspired from C++ code developped by DART team (Jianbo Qi, Tiangang Yin),
forDARTradiative transfer simulator.Creation date: 2019-05-24Author: Florian de BoissieuInstallPackagegdecompcan be installed with:pipinstallgdecompExampleimportgdecompimportnumpyasnpimportmatplotlib.pyplotaspltx=np.arange(100)gaus=np.array([[130,20,5],[50,50,10],[10,70,5]])y=np.zeros(x.shape)foriinrange(gaus.shape[0]):y+=gaus[i,0]/(np.sqrt(2*np.pi)*gaus[i,2])*np.exp(-(x-gaus[i,1])**2/(2*gaus[i,2]**2))out=gdecomp.GaussianDecomposition(y)out=np.reshape(out,(-1,3))fit=np.zeros(y.size)foriinrange(out.shape[0]):fit+=out[i,0]/(np.sqrt(2*np.pi)*out[i,2])*np.exp(-(x-out[i,1])**2/(2*out[i,2]**2))line1=plt.plot(x,y,color='k',label='waveform')line2=plt.plot(x,fit,color='r',linestyle='--',label='fit')plt.legend(loc='upper right')AknowledgementsThis package includes cmpfit source code ofCMPFIT library,
software developed by the University of Chicago, as Operator of Argonne Nationa Laboratory.
See src/mpfit/DISCLAIMER for copyright details of that code.
Package: gdemandfcast
gdemandfcastGeneric Python Package for Time Series Forecasting that seeks to include the latest over time and making it easy to use. 
Thus, including what is current and stable for non-profit or social use.UsageSee -> ./tests/test_example/test_hello.pyFeaturesDistribution Aware Auto Differentiation applied on Gradient Descent.Single and Multi Step Time Series (Stats, ML, DL)Preprocessing of Time Lags.Preprocessing of Walk Forward Validation.Whyhttps://www.clinfo.eu/mean-median/https://www.health.harvard.edu/blog/the-11-most-expensive-medications-201202094228ReleasesYou can see the list of available releases on theGitHub Releasespage.  
We useRelease Drafter. As pull requests are merged, a draft release is kept up-to-date listing the changes.LicenseThis project is licensed under the terms of theGNU GPL v3.0license.📃 Citation@misc{gdemandfcst,author={altcp},title={Generic Python Package for Time Series Forecasting},year={2021},publisher={GitHub},journal={GitHub repository},howpublished={https://github.com/altcp/gdemandfcast}}CreditsThis project was generated withpython-package-template
Package: gdetect
Gdetect library & clienta Python client and a library for GLIMPS Gmalware detect.Gdetect is a solution from GLIMPSInc.for a better detection of malware. Contact us atcontact@glimps.refor more information !DescriptionGdetect library aims to simplify use ofGlimps Detect, a malware detectio solution from GLIMPSInc..
This tool can be used by two ways:AsshellCLI:python3 -m gdetect /path/to/my/binaryAs python library (see below).InstallationFrom PyPIpython3-mpipinstallgdetectUsageAs shellCLItoolBefore launch the tool, you can set the path to your GDetect URL and your authentication token into environment variables with:export API_URL=https://my.gdetect.service.tldfor the URL;export API_TOKEN=abcdef01-23456789-abcdef01-23456789-abcdef01for the token.You can usegdetectin your shell like this:python3 -m gdetect /path/to/my/binaryto send your binary to API. This command return an UUID to you (sendis the default command, so you don't need to specify this).python3 -m gdetect get my_returned_uuidto get your result.To have some help:python3 -m gdetect --help:Usage:python-mgdetect[OPTIONS]COMMAND[ARGS]...

Options:--urlTEXTurltoGLIMPSDetectAPI--tokenTEXTauthenticationtoken--passwordTEXTpasswordusedtoextractarchive--insecuredisableHTTPScheck--no-cachesubmitfileevenifaresultalreadyexists--helpShowthismessageandexit.

Commands:send*sendfiletoAPI.getgetresultforgivenuuid.waitforsendafileandwaitfortheresult.searchgetresultforgivensha256.python3 -m gdetect waitfor /path/to/my/binaryallows you to send your binary and wait for a result (blocking mode). You can pass a--timeout Xoption with an integer to stop after X minutes.As a Python libraryAll stuff are done with aClientobject fromgdetect.api:fromgdetectimportClient# direct object import set in __init__ fileclient=Client(url='https://path/to/my/gdetect/service',token='qwerty012345678')uuid=client.push('my_bad_binary.exe')# wait some minutes to get a resultresult=client.get(uuid)print(result)Look at documentation for details about available methods, exceptions and more. To build internal documentation, usestoxtool inside your local clone of this repository (need extra packages:pip install -r requirements-dev.txt):tox-edocsAll documentations are now insidedocs/_build/htmldirectory.SupportIf you have any questions, open anissueon Github.ContributingIf you want to contribute, just follow theGithub PR flow.Install all needed library fromrequirements-dev.txt; update it if needed.Coverage your code with test (please usepytestfor that).Before submit yourpull request, please useblackas formatter,pylint(tox -e pylint) andflake8(tox -e flake8) as linter and test your code throught many versions. To do that, you can usetox(look attox.inifor options). Just launchtoxto do that.AuthorsGLIMPS dev core teamLicenseThis project is underMIT License.Project statusThis project is inBetadevelopment status. Feel free to participate !
Package: gdev-powertools
Aws Developmentversion: 0.0.1Papar InformationTitle:Paquete de pruebaAuthors:dolgasanz@gmail.comInstall & DependencepythonDirectory Hierarchy|—— LICENSE
|—— main.py
|—— mocks
|—— tests
|—— useful_tasks
|    |—— make_response.py
|    |—— utilities.py
|    |—— __init__.pyCode DetailsEste es un paquete con funciones personalizadas
Package: gdf2bokeh
Gdf2BokehAn easy way to map your geographic data (from a GeoDataFrame, a DataFrame and a list of dictionaries containing wkt or shapely geometries).Yeah! Because it's boring to convert shapely geometry to bokeh format each time I need to map something !!Also, this library let you to build complex Bokeh dashboard: no limitations to use Bokeh mecanisms.Check the demohereHow to install it ?with pippipinstallgdf2bokehWith Anacondacondainstall-camauryvalgdf2bokehHow to use it ?Gdf2Bokeh is able to map your data from various format. About data, you must be aware to use compliant geometry types:It supports Geo/DataFrame/List of dict/List of geometry containing these 4 geometries families:Point data with Point geometryMultiPoint data with MultiPoint geometryLine data with LineString and/or MultiLineString geometriesPolygon data with Polygon and/or MultiPolygon geometriesGeometryCollection data are not supported, so explode it to use it. So the best practice consists to split your input
data by geometry type.And you'll be able, optionally, to style your data thanks to the bokeh arguments :
Check bokeh documentation in order to style your data :Point / MultiPoint families:bokeh marker style optionsLine family:bokeh multi_line style optionsPolygon family:bokeh multi_polygon style optionsA simple examplefrombokeh.plottingimportshowimportgeopandasasgpdimportpaandasaspdfromgdf2bokehimportGdf2Bokehmap_session=Gdf2Bokeh()# add your layer from your data# Map a points GeoDataFrame. You can see marker style arguments, so we suppose that input_data contains Point geometrymap_session.add_layer_from_geodataframe("layer1",gpd.GeoDataFrame.from_file("your_poins_data.geojson"),size=6,fill_color="red",line_color="blue")# Map from a DataFrame. Style parameters are not requiredmap_session.add_layer_from_dataframe("layer2",pd.DataFrame.from_file("your_data.json"),geom_column="geometry",geom_format="shapely")# Map from a list of dictionnariesmap_session.add_layer_from_dict_list("layer3",[{"geometry":"POINT(0 0)","col1":"value1"},{"geometry":"POINT(1 1)","col1":"value2"}],geom_column="geometry",geom_format="wkt")# Map from a geometry (shapely, wkt...) listmap_session.add_layer_from_geom_list("layer4",["Point(0 0)","Point(5 5)"],geom_format="wkt")# Let's go to register them on bokehmap_session.add_layers_on_map()# Next, the map is displayedshow(map_session.figure)Here a bokeh basic example.
On the terminal, run :pythonexamples/bokeh_simple_case_example.pyOr you can use the jupyter notebook 'example.ipynb'An advanced exampleHere a bokeh serve example with a slider widget.
On the terminal, run :bokehserve--showexamples/bokeh_serve_example.py
Package: gdflib
About gdflibgdflib is a Python package made to dump GDF graph files.Installinggdflib can be installed from pypi:easy_install gdflibor:pip install gdflibshould just work for most of the usersUsageMost simple example:>>> from gdflib import GdfEntries, Node
>>>
>>> entities = GdfEntries()
>>> entities.add_node(Node(name='node1', label='This is the first node'))
>>> entities.add_node(Node(name='node2', label='This is the second node'))
>>> entities.link('node1', 'node2')
>>> print entities.dumps()
nodedef>name , style INT, width DOUBLE, color VARCHAR, image VARCHAR, label VARCHAR, height DOUBLE, visible BOOLEAN, labelcolor VARCHAR, y DOUBLE, x DOUBLE, strokecolor VARCHAR, fixed BOOLEAN, labelvisible BOOLEAN
node1,1,4.000000,cornflowerblue,,'This is the first node',4.000000,true,cornflowerblue,,,cadetblue,false,false
node2,1,4.000000,cornflowerblue,,'This is the second node',4.000000,true,cornflowerblue,,,cadetblue,false,false
edgedef>node1 , node2 , directed BOOLEAN, color VARCHAR, weight DOUBLE, width DOUBLE, label VARCHAR, visible BOOLEAN, labelcolor VARCHAR, labelvisible BOOLEAN
node1,node2,true,dandelion,1.000000,3.000000,'1',true,dandelion,falseBy default all nodes implement the standard properties defined for GDF, unspecified properties will get
the default value.
Customnodescan be defined through theDeclarativeinterface:>>> from gdflib import String, Double
>>> from gdflib import GdfEntries, Node
>>>
>>> class Product(Node):
...     company = String(default='Unknown Company')
...     price = Double(required=True)
...
>>> entities = GdfEntries(Product)
>>> entities.add_node(Product(name='node1', company='Custom Company', price=33.10))
>>> entities.add_node(Product(name='node2', label='Low Cost Product', price=18.21))
>>> entities.link('node1', 'node2')
>>> entities.dumps()
nodedef>name , style INT, width DOUBLE, color VARCHAR, image VARCHAR, label VARCHAR, height DOUBLE, visible BOOLEAN, labelcolor VARCHAR, y DOUBLE, x DOUBLE, strokecolor VARCHAR, fixed BOOLEAN, labelvisible BOOLEAN, company VARCHAR, price DOUBLE
node1,1,4.000000,cornflowerblue,,'node1',4.000000,true,cornflowerblue,,,cadetblue,false,false,'Custom Company',33.100000
node2,1,4.000000,cornflowerblue,,'Low Cost Product',4.000000,true,cornflowerblue,,,cadetblue,false,false,'Unknown Company',18.210000
edgedef>node1 , node2 , directed BOOLEAN, color VARCHAR, weight DOUBLE, width DOUBLE, label VARCHAR, visible BOOLEAN, labelcolor VARCHAR, labelvisible BOOLEAN
node1,node2,true,dandelion,1.000000,3.000000,'1',true,dandelion,falsegdflib provides also support for customedges, those can be defined like custom nodes
by subclassingEdgeand providing additional attributes. In such case instead of usinglinkfunction to link two nodes,add_edgecall should be uses.
Package: gdgen
GDGenVersion: 1.0-alphaAn advanced, configurable code generator which aims to automate some aspects ofGodot Enginedevelopment, namely:creating C++ modules;creating GDNative plugins.Currently only C++ module generation is supported, so most of the functionallity
is revolving around modules.RequirementsPython 3.6+Git (optional)CompatibilityGodot Engine 3.0+ (C++ modules generation)Installationpipinstallgit+https://github.com/Xrayez/gdgenUsagegdgen[-nNAME][-sINTERNAL_NAME][-cCONFIG_PATH][-oOUTPUT_PATH]ExamplesFor most use cases, you can use a simple wizard. Here's an example output:$ ~/src/godot/modules> gdgen

Module name: My awesome module
Internal module name (snake_case): my_module
Author name (default - You): Me
Engine version (default - latest): 3.1
C++ version (default - c++11): c++20
Number of classes to generate (default - 0): 1
(0) Class name: NewNode
(0) Class inherits: Node
(0) Class path (default - ):
Documentation path (default - docs): doc_classes
Icons path (default - editor/icons): icons
Thirdparty path (default - thirdparty):
Initialize README? (default - True):
License (default - MIT):
Version control system (default - git):
Will be included inside project? (default - False): True
Initialized empty Git repository in ~/src/godot/modules/my_module/.git/You can also create your own configuration file:gdgen-ctests/configs/sample.json-o~/src/godot/modules/Use default config file, but fill the required fields manually:gdgen-nMyModule-smy_moduleConfigNameDescriptionname(Required) Descriptive name of the module.internal_name(Required) The name used by the engine for the module to compile. This name is used by default for any unnamedclassesto be generated later (see below).authorThe name that will be used to place inside license text. If not set explicitly, the generator is going to attempt to retrieve one with the help of supported version control provider. In case ofgit, it will usegit config user.namevalue.engine_versionThe engine target version used to generate compatible module.cpp_versionThe C++ version to compile module-specific source files.classesAn optional array to generate Godot classes. Available fields:name- the class name;inherits- one of the base (Godot) core classes;path- relative base directory to generate classes in.docs_pathIf set, configures the module to use module-specific documentation forclasses.icons_pathIf set, configures the module to use module-specific editor icons forclasses.thirdparty_pathIf set, configures the module to apply common operations on third-party code (disabling warnings etc).readmeIftrue, initializes a barebones README file with module installation instructions.licenseIf set, creates LICENSE file with current year and author substituted from available license templates.version_controlIf set, attempts to initialize the module with version control provider of choice.to_be_included_inside_projectIftrue, creates.gdignorefile so that the module can be included inside regular Godot project (for instance, prevents*.objbuild files to be wrongly recognized and imported as 3D models).
Package: gdget
A simple command line utility to download Google Drive public URLs
effortlessly.InstallationpipinstallgdgetUsageDownload using google drive urlgdgethttps://drive.google.com/file/d/1rcZ42siSqpLlVx2LRR_xjD7uJA8twKEa/viewDownload using Google drive IDgdget1rcZ42siSqpLlVx2LRR_xjD7uJA8twKEaRequirementsPython >=2.6 & >=3.4 (does not support 3.3)requeststqdmpytest (optional, to run tests)LicenseThe MIT License