Saravanan666/pypi-org huggingface dataset:
Package: generatorGUI
# generatorGUIEdit parameters for the Astra generator program and run generator using a GUI.### PurposeSummarizes all the parameters for Astra generator in a table and displays it inthe PyQtenvironment.The parameters are saved in an *Excel* format. The user can start from ablank "all-default" table, or load an Excel file with parameters alreadydefined in it. The parameters can be changed and saved again to the Excelspreadsheet.When all the necessary parameters are defined in the PyQt table, simply click"Run" to execute the Astra generator.### UsageThe script can be executed in two ways. Both ways require some basicinformation about how to run Python scripts, of course.* Option 1: **Run script from command line**```BASH> python /path/to/your/pip/installation/generatorGUI/main.py```For instance, on my OSX I used `pip` installed by *anaconda*, such thatthe packages are installed in my *anaconda* diretory. So for me:```BASH> python  ~/anaconda3/lib/python3.7/site-packages/generatorGUI/main.py```* Option 2: **Import the module and run the main function**You can also run the GUI from the Python prompt, or *Jupyter notebook*,for instance:```Python>>> import generatorGUI>>> generatorGUI.main()```For each of the parameters, the *type*, *unit*, and *default* have alreadybeen defined. Do not change the values in those cells. If a parameter needsto be modified from its default value, enter the correct value in the *set*column.Notice, that for *str* type, the value does not need the single quotes 'around the string; the *list_?* type asks for a list of *?* type values: e.g.for *list_float* you can put `[1.0, 2.0, 3.0]`, just like a *Python list*,for *list_str*, single quotes ' are not needed either: e.g. `[abc.dat, foo.dat]`.####A note on the parameter *fname*Notice that by default the *generator* program will be called from thecurrent working directory, i.e. where you run the **main.py** script. If onlya file name is### InstallationInstall easyexception using `pip`, or `pip3`pip install generatorGUI### Repository[GitHub page](https://github.com/frankliuao/generatorGUI)
Package: generator-oj-problem
A command-line tool to generate Online-Judge problem.Render problem descriptions in Markdown to HTMLCheck problem descriptions and data, including missing fields, UTF-8 encoding, end-of-line CRLF/LFPacking problem data in freeproblemset(hustoj) formatMechanism for generating input and output test dataEasy to define adapters for other online-judge platformHave fun! If you have any suggestions or find any bugs, please tell me.Installpipinstallgenerator-oj-problem# or use pipx for a standalone python environmentpipinstallpipx
pipxensurepath
pipxinstallgenerator-oj-problem

gop--helpUsage# Initialize your problemgopinit# Modify the files to write problemls.# Generate 2 sample data from id 1gopgen-s1-c2--sample# Generate 5 test data from id 2gopgen-s2-c5# Trim sample and test datagoptrim# Check validatygopcheck# Pack your problem in FreeProblemSet formatgop-afpspackIf you meet some encoding errors, ensure your Python interpreter runs in UTF-8 mode, e.g. addingPYTHONUTF8=1to your environment variables.Directory StructureHere is a demo problemA + B Problem. Details aboutproblem.ymlandgenerator.pyare given at the comments of the demo files.The file with extension.mdmeans it supports plainCommonMarkby built-in render.Attention: No LaTeX and embeded image supports.problem.ymlProblem metadata and configurationdescription.mdDescriptioninput.mdDescription of inputoutput.mdDescription of outputhint.mdHintsolution.txtSolution source codegenerator.pyGenerator for input or output data.samples/Sample datasamples/0.inInput of samplesamples/0.outOutput of sampletests/Test data (same form tosamples/)
Package: generator_tools
The generator tools package enables copying and pickling running generators inCPython ( you don't need Stackless Python ).Usage-----from generator_tools.copygenerators import*from generator_tools.picklegenerators import*def f(start):i = startwhile i<start+10:yield ii+=1>>> f_gen = f(5)>>> f_gen.next()   # or next(f_gen) in Python 3.05>>> f_gen.next()6>>> g_gen = copy_generator(f_gen)>>> h_gen = copy_generator(f_gen)>>> g_gen.next()7>>> h_gen.next()7>>> pickler = GeneratorPickler("test.pkl")>>> pickler.pickle_generator(g_gen)>>> k_gen = pickler.unpickle_generator()>>> list(g_gen) == list(k_gen)True
Package: generax
generaxgenerax provides implementations of flow based generative models.  The library is built on top ofEquinoxwhich removes the need to worry about keeping track of model parameters.key=random.PRNGKey(0)# JAX random keyx=...# some data# Create a flow modelmodel=NeuralSpline(input_shape=x.shape[1:],n_flow_layers=3,n_blocks=4,hidden_size=32,working_size=16,n_spline_knots=8,key=key)# Data dependent initializationmodel=model.data_dependent_init(x,key=key)# Take multiple samples using vmapkeys=random.split(key,1000)samples=eqx.filter_vmap(model.sample)(keys)# Compute the log probability of datalog_prob=eqx.filter_vmap(model.log_prob)(x)There is also support for probability paths (time-dependent probability distributions) which can be used to train continuous normalizing flows with flow matching.  See the examples on flow matching and multi-sample flow matching for more details.Installationgenerax is available on pip:pipinstallgeneraxTrainingGenerax provides an easy interface to train these models:trainer=Trainer(checkpoint_path='tmp/model_path')model=trainer.train(model=model,# Generax modelobjective=my_objective,# Objective functionevaluate_model=tester,# Testing functionoptimizer=optimizer,# Optax optimizernum_steps=10000,# Number of training stepsdata_iterator=train_ds,# Training data iteratordouble_batch=1000,# Train these many batches in a scan loopcheckpoint_every=1000,# Checkpoint intervaltest_every=1000,# Test intervalretrain=True)# Retrain from checkpointSee the examples folder for more details.
Package: genereg
generegThis library implements a method for analyzing the regulation systems of target genes in a specific genetic pathology, such as a cancer. Adopting a linear regression approach, it builds a predictive model for the regulation of target genes expression, in order to identify the relevant features that explain the regulation of each gene of interest within patients affected by the pathology under analysis.
The regulation system of each target gene is analyzed singularly and independently, by assessing the effect of multiple regulatory factors on its expression, such as its methylation, the expression of other genes or the effect of transcription factors.The full documentation can be found at the following link:https://genereg.readthedocs.io
Package: generi
📚Documentation🐳 AboutGeneri is a tool to automatically create Dockerfiles and build images for a large combination of different factors. It is the right tool if you need to build many similar images with slightly different parameters.For example, say you are developing an app. You might want to build one docker image for python 2.7, 3.6, 3.8. And for each python version, you need one with a database included or not. And all that for each tag. If you have experienced a scenario like this, try out Generi.🎇 FeaturesConfiguration in yamlSpecify different parameter to form a build matrixGenerate Dockerfile for each combinationBuild all variations of your image with one commandPush to the repository of your choiceEverything customisable usingJinja✈️ QuickstartGenerican be configured using a simple yaml file that defines your matrix build.schema.yamlparameters:python_version:-2.7-3.5-3.6-3.7operating_system:-buster-alpinetemplate:templatesoutput:"output/{{python_version}}/{{operating_system}}"image:"nicklehmann/myapplication:py{{python_version}}-{{operating_system}}"registry:username:nicklehmanntemplates/DockerfileFROMpython:{{python_version}}-{{operating_system}}COPYmain.pymain.pyCMD["python","main.py"]First, render your dockerfiles by running$generiwriteschema.yamlAfter that, build and optionally push your image.$generibuildschema.yaml
$generipushschema.yamlFor more examples, please see theusagesection of the documentation.
Package: generic
Generic programming library for PythonGeneric is a library forGeneric programming, also known asMultiple dispatch.The Generic library supports:multi-dispatch: likefunctools.singledispatch, but for more than one parametermulti-methods: multi-dispatch, but for methodsevent dispatching: based on a hierarchical event structure (event objects)You can readdocumentationhosted at
excellent readthedocs.org project. Development takes place ongithub.Changes1.1.2Replace print statements with loggingEnable trusted publisher for PyPICreate Security PolicyUpdate LICENSE to BSD 3-ClauseAdd support for Python 3.12Simplify build: drop toxUpdate documentation theme to FuroSwitch linting to ruff1.1.1Add support for Python 3.11Move mypy configuration to pyproject.tomlEnable automatic release of new versions with CI1.1.0Renamemasterbranch tomaingeneric.event.Managerexecutes all handlers and throws anExceptionGroupin case of errors1.0.1Add Support for Python 3.10, Drop Support for Python 3.7Enable Pre-commit Hooks for isort, toml, yaml, pyupgrade, docformatter, and flake8Migrate to GitHub Actions1.0.0Updated documentation onReadthedocsFixmultimethod.otherwiseclause1.0.0b1Ported the code to Python 3.7, Python 2 is no longer supportedMultimethods now have their own moduleThe interface now mimicsfunctools.singledispatch:thewhenmethod has been renamed toregisteroverriding of methods is no longer possible0.3.1Minor fixes in distribution.0.3Event management with event inheritance support.0.2Methods with multidispatch by object type and positional arguments.Override multifunctions withoverridemethod.0.1Registry with simple and type axes.Functions with multidispatch by positional arguments.
Package: generic-api
Polls is a Django app to reach external APIs by mirroring DRF architecture.Quick startAdd “generic_api” to your INSTALLED_APPS setting like this:INSTALLED_APPS = [
    ...
    'generic_api',
]Create your session class that will hold the authentication and the base URL:from generic_api.session import ConstanceSessionclass MySession(ConstanceSession):base_url = ‘https://baseurl/v1/’
constance_key = ‘MY_TOKEN’Create the client that will perform the queries:from generic_api.errors_handler import HttpErrorsHandler
from generic_api.generics import GenericClientclass MyClient(GenericClient):session_class = MySession
errors_handler_class = HttpErrorsHandlerCreate the serializers for requests and responses:class MyRequestSerializer(serializers.Serializer):name = serializers.CharField()class MyResponseSerializer(serializers.Serializer):id = serializer.IntegerField()Those are used to valid the request performed and the response received. If allows to detect quickly if something
changed on the remote APICreate your endpoint:from generic_api.endpoints import GetEndpointclass MyEndpointEndpoint(GetEndpoint):endpoint_url = ‘search/by_name’  # This can take argument, like endpoint_url: ‘{}/list’
client_class = MyClient
response_entity_class = MyResponseSerializer
request_entity_class = MyRequestSerializerIf your serializer are ModelSerializer, the object can be saved.Use the endpoint:endpoint = MyEndpoint()data = endpoint.get(**kwargs)
data = data.save()This project is available on GitHub:https://github.com/guestready/generic_api
Package: generic-api-wrapper
Generic API wrapperversion=0.2.0generic-api-wrapperis a generic REST API python wrapper. It comes with an AWS IAM authenticator out of the box.Getting startedInstallpip install generic-api-wrapperUsageBasic usagefromgeneric_api_wrapperimportApi# To create an API wrapper object provide base url# Let's take Github for exampleapi=Api("https://api.github.com")# Get repos of a user# This is equivalent to sending a GET request to# https://api.github.com/users/grishasergii/reposrepos=api.users.grishasergii.repos()# If a resource name violates Python attributes syntax then use __getitem__# This is equivalent to sending a GET request to# https://api.i-do-not-exist.com/resources/imaginary-resourceimaginary_api=Api("https://api.i-do-not-exist.com")resource=api.resources["imaginary-resource"]()# provide data for POST requestimaginary_api.resources.post(data={"name":"resource-name"})AuthenticationAWS IAM authneticationfromgeneric_api_wrapperimportApi,AwsIamAuthapi_url="https://api.aws-powered-api.com"# AWS IAM authentication. Credentials and AWS region are inferred by boto3 from the app environmentauth=AwsIamAuth(api_url).auth# Create an API wrapper object that is authenticated to call an API configured with an AWS IAM authorizerapi=Api(api_url,auth)custom authenticator: create a custom authenticator that fits your requirements
and provide it to theApiconstructor, it will be passed to thesessionobject when sending a request.LicenseFree software: MIT licenseCreditsThis package was created with Cookiecutter_ and theaudreyr/cookiecutter-pypackage_ project template.Cookiecutter:https://github.com/audreyr/cookiecutteraudreyr/cookiecutter-pypackage:https://github.com/audreyr/cookiecutter-pypackage
Package: generic-args
generic-argsGiven an instantiated generic class, retrieve the type arguments of itself or its parents.The packages solves the problem described atthis StackOverflow question.Installationpipinstallgeneric-argsExampleShowcase how your project can be used:fromtypingimportListfromgeneric_argsimportgeneric_type_argsgeneric_type_args(List[int])# (<type 'int'>, )LicenseMITCreditsThis project was generated withwemake-python-package. Current template version is:54efe958f72ac06e912a1423aa14be8b149f988f. See what isupdatedsince then.
Package: generic-binary-sharding
Generic Binary Sharding ToolThis tool is a Generic Binary Sharding tool which serializes binaries into a javascript package where each file is at max a specified shard size.How it WorksThis tool works by determining all the files that match the given criterion (extensions and paths). We read all of these files and store the base64 encoding of their bytes in a dictionary. Later we write a bunch of js files having a maximum ofshard_sizemegabytes size. By default this is set to 64MB.Finally an entrypoint file is provided which requires all the appropriate files.DCP ModulesThis tool was built to aid in development of dcp packages and for publishing extremely large models and binary files. As such, we've also included some dcp based package generation features.These features take advantage of a feature bravojs module packages have calledmodule.provide. This feature allows users to request packages to load in dynamically that weren't explicitly required byjob.requires.
Package: generic_celery_task
problemThe Celery daemon needs to be restarted every time an existing task is
modified or new tasks are added.solutionUse only one Celery task that’s generic enough to run arbitrary Python
functions with arbitrary arguments and wrap this task in a custom
decorator.As a bonus, the job will still work (synchronously) when Celery/the
broker are not running.The job’s calling API is the same as Celery’s: .s(), .delay() and
.apply_async()examplein celeryapp.py which is in the same directory as celeryconfig.py,
create a Celery app and then import the custom decorator:importceleryimportosimportsyssys.path.insert(0,os.path.join(os.path.dirname(__file__),'.'))#os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'settings')app=celery.Celery()app.config_from_object('celeryconfig')fromgeneric_celery_task.decoratorsimporttaskstart Celery along with its broker. You no longer need to restart
Celery after this.in another file, importable from celeryapp.py, create your task:fromceleryappimporttask@taskdefjob(x,y):return'x + y =%d'%(x+y)now use it:importcelery# direct function callassertjob(1,2)=='x + y = 3'# using the delay() methodres=job.delay(1,2)# if the Celery daemon and its backend broker are running, 'res' is an instance of AsyncResultifisinstance(res,celery.result.AsyncResult):assertres.get()=='x + y = 3'else:# if either one is not running, a warning is issued and the function is executed synchronously# with 'res' being the actual function result# if you want to silence the warnings, use '@task(quiet=True)'assertres=='x + y = 3'# using the apply_async() methodres=job.apply_async(args=[1,2])# and process the result as above, if you need toinstallationA setup.py is provided. You know what to do with it.testingThe tests require nose, redis, redis-py and assume that the port 6389 is
free.Run the tests with “python setup.py test” or with “nosetests -v”.This package was tested with python-2.7.6, python-3.3.4, nose-1.3.0,
celery-3.1.10, redis-2.8.7 and redis-py-2.9.1 .caveatsthe module which holds your custom task will be reloaded. If it
contains a class using ‘super’ and its instance, you might run into
the problem describedhere.
Apply one of the proposed fixes.the state of the Celery daemon and its broker are checked only once,
when the first .delay() or .apply_async() method is called on a
custom task.creditsauthor: Stefan Talpalarustefantalpalaru@yahoo.comhomepage:https://github.com/stefantalpalaru/generic_celery_task
Package: generic-decorators
generic-decoratorsGeneric Python Decorators for use in any project.Installgeneric-decoratorsis released to public PyPI -generic-decorators. It can be installed using this command:pip install generic-decoratorsDecoratorsmake_parallelSummary: runs function in parallel instead of sequencial for loop.ExampleParallel trigger of functionssample_functionwith 1 paramlist_of_post_idsusingmake_paralleldecorator and equivalent sequential trigger usingfor loop.defparallel_function_trigger():list_of_post_ids=list(range(1,20))returnmake_parallel(sample_function)(list_of_post_ids)#equivalent sequencial versiondefserial_function_trigger():list_of_post_ids=list(range(1,20))# Serial way of calling the functionresults=[]forpost_idinlist_of_post_ids:res=sample_function(post_id)results.append(res)returnresultsYou can use belowtimingdecorator to compare time of above parallel
and sequential versions.make_parallel_processesDescription: Similar functionality likemake_parallelbut
usesmulitprocessinginstead ofthreading.Exampledefparallel_function_trigger():list_of_post_ids=list(range(1,20))returnmake_parallel_processes(sample_function)(list_of_post_ids)timingSummary: calculate and print how much time function processing took.Example@timingdefsleep_n_seconds(n:int):time.sleep(n)sleep_n_seconds(5)It should print something like this (time can differ):func:'sleep_n_seconds' args:[(5,), {}] took: 5.0047 secsingletonSummary: make class Singleton - class which will have max 1 instance createdExample@singletonclassMyClass(object):"""docstring for MyClass"""def__init__(self):passforiinrange(0,10):obj=MyClass()print(obj)It should print something like this (all objects of class are the same):<__main__.MyClass object at 0x7fc3bc38fc50>
<__main__.MyClass object at 0x7fc3bc38fc50>
<__main__.MyClass object at 0x7fc3bc38fc50>
<__main__.MyClass object at 0x7fc3bc38fc50>
<__main__.MyClass object at 0x7fc3bc38fc50>
<__main__.MyClass object at 0x7fc3bc38fc50>
<__main__.MyClass object at 0x7fc3bc38fc50>
<__main__.MyClass object at 0x7fc3bc38fc50>
<__main__.MyClass object at 0x7fc3bc38fc50>
<__main__.MyClass object at 0x7fc3bc38fc50>
Package: generic-encoders
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the “Software”), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Description: UNKNOWN
Keywords: encoders,gzip,compression,decompression
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: Natural Language :: English
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.6
Requires-Python: >=2.7
Provides-Extra: snappy
Provides-Extra: dev
Provides-Extra: all
Package: generic-encryptors
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the “Software”), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Description: UNKNOWN
Keywords: encryptors,encryption,aes,decryption
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: Natural Language :: English
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.6
Requires-Python: >=2.7