Saravanan666/pypi-org huggingface dataset:
Package: membrane-curvature
Membrane CurvatureMembraneCurvature is anMDAnalysistool to calculate membrane curvature from
Molecular Dynamics simulations.Interested in becoming a maintainer?We welcome your passion and expertise to help shape and grow this open-source project! Please contactestefania@ojeda-e.comfor more details.FeaturesWith MembraneCurvature you can:Calculate mean and Gaussian curvature from MD simulations.Derive 2D curvature profiles.Live a happier life.InstallationThe main dependency in MembraneCurvature isMDAnalysis. You can find
instructions to install the latest stable version of MDAnalysis viacondain theUserGuide.MembraneCurvature is available viapip:pip install membrane-curvatureTo install from source:git clone https://github.com/MDAnalysis/membrane-curvature.git
cd membrane-curvature
conda env create -f devtools/conda-envs/environment.yaml
conda activate membrane-curvature
python setup.py installSome of the examples included in the MembraneCurvature documentation use test
cases fromMDAnalysisTests. To install the unit tests viaconda:conda install -c conda-forge MDAnalysisTestsor viapip:pip install --upgrade MDAnalysisTests⚠️ In comparison to the previous version,membrane-curvature==0.0.3shows a significant improvement in performance, particularly notable for membrane-protein systems. Installing the last available version is highly encouraged.UsageThis is a quick example on how to run MembraneCurvature:importMDAnalysisasmdafrommembrane_curvature.baseimportMembraneCurvaturefromMDAnalysis.tests.datafilesimportMartini_membrane_grouniverse=mda.Universe(Martini_membrane_gro)curvature_upper_leaflet=MembraneCurvature(universe,select='resid 1-225 and name PO4',n_x_bins=8,n_y_bins=8,wrap=True).run()# extract mean curvaturemean_upper_leaflet=curvature_upper_leaflet.results.z_surface# extract mean curvaturemean_upper_leaflet=curvature_upper_leaflet.results.mean# extract Gaussiangaussian_upper_leaflet=curvature_upper_leaflet.results.gaussianIn this example, we use the PO4 beads in the upper leaflet as reference to
derive a surface and calculate its respective mean and Gaussian curvature.You can find more examples on how to run MembraneCurvature in theUsagepage.
To plot results from MembraneCurvature please check theVisualizationpage.DocumentationTo help you get the most out MembraneCurvature, we havedocumentationavailable
where you can find:The standardAPIdocumentation.Quick examples of how to run Membrane Curvature in theUsagepage.Detailed explanation of theAlgorithmimplemented in MembraneCurvature.Examples on how to plot the results obtained from MembraneCurvature in theVisualizationpage.LicenseSource code included in this project is available in the GitHub repositoryhttps://github.com/MDAnalysis/membrane-curvatureunder the GNU Public License
v3 , version 3 (seeLICENSE).MembraneCurvature was developed as aGoogle Summer of Code 2021project withMDAnalysisand it is linked to aCode of Conduct.Copyright (c) 2021-2022, Estefania Barreto-Ojeda
Package: membrete
Membreteis a Django application which provides an easy to use contact formallowing to store contact messages in the database.If you are using it and have ideas for it I’ll be more than happy to hear them!FeaturesMessages are stored in the databaseRecipients are Users (from django.contrib.auth)Internationalization supportSupport for using templates for messagesAJAX supportAlternativesdjango-contact-formis an extensible and very flexible contact form app
for Django (from which membrete borrows some ideas)Super quick startGo to thedevprojectdirectory and run the following commands:python manage.py syncdb
python manage.py runserverGo tohttp://localhost:8000/to see Membrete in action!InstallationSimply run the setup.py script as root, like this:python setup.py installUsageTo use Membrete in your project, just follow this simple steps:AddmembretetoINSTALLED_APPSin yoursettings.pyfileRunpython manage.py syncdbunder your project directory to create
membrete’s tablesEdit the urls.py file and add something like this tourlpatterns:(r'^contact$', include('membrete.urls')),Done! Fire up the server and go tohttp://localhost:8000/contactNOTE: membrete’s templates expect abase.htmltemplate to extend from.SourceBranch Membrete usingBazaar:bzr branch http://gonzalodelgado.com.ar/bzr/membrete/main membreteMore infoGet more information about membrete from itswebsiteIf you have any questions feel free toemailme anytime.
Package: memcache
memcacheExperimental memcached client library for python. This project is in WIP status, please don't use it in production environment.Key features:Based on memcached's new meta commands;Asyncio support;Type hints.Installation$pipinstallmemcacheAbout the ProjectMemcache is © 2020-2021 byaisk.LicenseMemcache is distributed by aMIT license.
Package: memcache_clone
clone memcache data to other memcacheUsage Example:from memcache_clone import memcaches = memcache('127.0.0.1',11211)s.con()#set(key,value,len,flags,express)s.set("key","value",5,0,0)#get(key) return list : list[value,value_len,flags]s.get("key")[0]#clones.clone('127.0.0.1',11212)
Package: memcached_lock
memcached_lockImplements a distributed transaction using memcached or
a memcached compatible storage.ExampleBasic example of usage:from __future__ import with_statement
import memcache
from memcached_lock import dist_lock

client = memcache.Client(['127.0.0.1:11211'])
with dist_lock('test', client):
    print 'Is there anybody out there!?'
Package: memcached-search
memcached-searchA simple tool for finding keys and values in a memcached server or cluster. Especailly good for locating values in WordPress's object cache when you do not know the cache key.InstallingInstall from pip:pipinstallmemcached-searchRequirementsSupports Python 2 and 3 (tested on 2.7.15 and 3.6). Requires the following packages:Click
pymemcache
future
future-fstringsUsageUsage:memcached-search[OPTIONS]COMMAND[ARGS]...Debugyourmemcachedserverbysearchingforcachekeys

Options:--hostTEXTmemcachedserverip--portINTEGERmemcachedport--helpShowthismessageandexit.

Commands:findsearchforcachekeysmatchingaregex...getGetvaluefromcachebycachekeyitemsListallitemsinmemcachedserverConfigurationBy default, memcached-search connects to memcached runnging on localhost, on the default port of 11211. This can be customized by creating a JSON formatted config file in the current users home directory:~/.memcached-search. This file should contain a JSON array whos elements are arrays of server and port combonations for each server to connect to.[["localhost",11211],["localhost",11212]]
Package: memcachelock
Python module using memcache as a lock server.Disclaimer: This code is inspired by unimr.memcachedlock . I thought I could
write a simpler version of MemcachedRLock class to keep dependencies minimal
(python builtins plus python-memcache), and enforcing support of gets/cas API.WARNING: little testing has been done so far. Better review & stress
this code before using it anywhere for the moment.Example usage:
import memcachelock
import memcache
# python-memcached doesn’t do cas correctly without cache_cas
mc = memcache.Client([‘127.0.0.1:11211’], cache_cas=True)
# Non-reentrant lock
mclock = memcachelock.Lock(mc, ‘foo_resource’)
# Per-connection reentrant lock
mcrlock = memcachelock.RLock(mc, ‘foo_resource’)
# Per-connection and per-thread reentrant lock
rmcrlock = memcachelock.ThreadRLock(mc, ‘foo_resource’)All lock instances have the same API as thread.LockType (as of python
2.7).
‘foo_resource’ is any string usable as a memcache key identifying some
resource this lock protects. In Zope world, it might be a traversable object’s
path, or a database identifier plus some database-scoped unique identifier…
Package: memcache-lock
# memcache_lock
Simple locking mechanism for Python 2.7 GAE, using memcache## UsageImport the UUIDLock class in any app engine module` from memcache_lock import UUIDLock `Acquire the lock` lock_helper =UUIDLock(key='lock_key')lock_helper.lock() `Release the lock` lock_helper.release() `## Options### You use other kwargs to control the lock mechanismSend default_timeout in secs to change the time after with the lock will be released automatically` lock_helper =UUIDLock(key='lock_key',default_timeout=3600) `NOTE: default value for timeout is 24 hoursSend force_lock as True to acquire lock even if some other application already has lock on the key` lock_helper =UUIDLock(key='lock_key',force_lock=True) `NOTE: default value for force_lock is FalseSend max_wait_time in secs to raise Exception if lock is not acquired after waiting for max_wait_time` lock_helper =UUIDLock(key='lock_key',max_wait_time=120) `NOTE: default value for max_wait_time is 60 secs
Package: memcache_toolbar
The Memcache Debug Toolbar is an add-on for Django Debug Toolbar for tracking
memcached usage. It currently supports both thepylibmcandmemcachelibraries.This is definitely beta software, but I’ve found it useful in work and personal
projects. Feedback welcome, patches appreciated. - Ross McFarlandInstallationInstall and configureDjango Debug Toolbar.Add thememcache_toolbarapp to yourINSTALLED_APPS.Import the panel corresponding to the library you’re using.The following must be imported in yoursettings.pyfile so that it has a
chance to replace the caching library with one capable of tracking. You’ll
probably want to import it inlocal_settings.py(if you use the pattern) or
at least wrap the import line inif DEBUG:Formemcache:import memcache_toolbar.panels.memcacheForpylibmc:import memcache_toolbar.panels.pylibmcConfigurationAdd thememcacheorpylibmcpanel toDEBUG_TOOLBAR_PANELS.You’ll need to add the panel corresponding to the library you’ll be using to
the list of debug toolbar’s panels in the order in which you’d like it to
appear:DEBUG_TOOLBAR_PANELS = (
    ...
    'memcache_toolbar.panels.memcache.MemcachePanel',
    # if you use pylibmc you'd include its panel instead
    # 'memcache_toolbar.panels.pylibmc.PylibmcPanel',
)
Package: memcache_wrapper
A Python function wrapper to cache method results using memcacheUsage:from memcache_wrapper import Memcachedfrom mockcache import Clientmc_client = Client()@Memcached('/myprefix', mc_client)def myfunc(args):...ormc = Memcached('/myprefix', mc_client)cached_myfunc = mc.wrap(myfunc)For short,cached_myfunc = Memcached('/myprefix', mc_client).wrap(myfunc)See more examples at test/test_memcache_wrapper.pyParameters:prefix: used as memached's key prefixmc_client: memcache client instance, such as python-memcached or mockcachettl: time to live in memcache, default: 10bypass_cache: if True, bypass cache and save the resultcache_negative: if False, do not cache negative result, such as [], {}, and None. Otherwise, it will cache everything.
Package: memcachier-django-ascii
# memcachier-django-asciiThis package provides a memcached cache backend for Django using[pymemcache](https://github.com/pinterest/pymemcache). We generallyprefer [pylibmc](https://github.com/lericson/pylibmc) but it dependson a [libmemcached](http://libmemcached.org) which can sometimes causeissues. Pymemcache is a pure python client.This package only works with the ASCII protocol and a single memcacheserver.*NOTE:* In general we recommend[django-pylibmc](https://github.com/jbalogh/django-pylibmc/), but inrare situations this package works better.## MemCachier & AuthenticationThis backend only supports the memcached ASCII protocol, whichnormally doesn't support authentication. MemCachier requiresauthentication, and adds it in very simply by requiring all newconnections issue a set:```$ set <username> 0 0 <password length>\r\n$ <password>\r\n```formatted as above to communicate credentials.## RequirementsRequires Django 1.3+. It was written and tested on Python 2.7.## InstallationGet it from pypi:```$ pip install memcachier-django-ascii```or github:```$ pip install -e git://github.com/memcachier/django-ascii.git```## UsageYour cache backend should look something like this:```CACHES = {'default': {'BACKEND': 'memcache_fix.backend.PyMemcacheCache','OPTIONS': {'no_delay': True,'connect_timeout': 2,'timeout': 2,}}}```*NOTE*: The backend currently only supports connecting to one server.## Configuration with Environment VariablesOptionally, the memcached connection can be configured withenvironment variables (on platforms like Heroku). To do so, declarethe following variables:```MEMCACHE_SERVERSMEMCACHE_USERNAMEMEMCACHE_PASSWORD```## AuthorForked from [django-pymemcache](https://github.com/jsocol/django-pymemcache).## Get involved!We are happy to receive bug reports, fixes, documentation enhancements,and other improvements.Please report bugs via the[github issue tracker](http://github.com/memcachier/django-ascii/issues).Master [git repository](http://github.com/memcachier/django-ascii):* `git clone git://github.com/memcachier/django-ascii.git`## LicensingThis library is licensed under the Apache Software License 2.0
Package: memcalc
—Name: memcalcVersion: 0.0.1Description: memcalc is a Python package made for performing essential math calculations for everyday use.Supported Actions:AdditionMultiplicationSubtractionDivisionnth root calculationMemory resetPrint out memory—
How to install this package:installing via terminal -pip install memcalcinstalling via IDE -%pip install memcalc—
How it works:from calculator.calculator import Calculatornew_obj = calc.Calculator()  # New object is created.new_obj.add(55) # Returns 55.0new_obj.subtract(22.6) # Returns 32.4new_obj.multiply(5) # Returns 162.0new_obj.divide(2) # Returns 81.0new_obj.n_root(4) # Returns 3.0new_obj.return_memory # Returns 3.0new_obj.memory_reset() # Resets memory to 0.0—Keywords: calculator, addition, multiplication, subtraction, division, nth rootThis project is licensed under the terms of the MIT license.
Package: memdb
MemDBAn in-memory agnostic database for Python.Change history0.0.5TheDataset.to_str()method now has the limit parameter to define the number of lines that should be displayed.Added theDataset.all()method to return all data, without applying any filters.Added theformatparameter in theadd_field()method. This parameter is passed to the method of theSchemaclass and is used by it to define a format for the new field created.Addeddate_formatattribute to Dataset class. This attribute is used whenever values are entered in fields of typedateordatetimeto store the value in the intended format.Validation of values at insertion time. Fields of typedateordatetime, when receiving a value of typestr, check the string format. If it's a valid date, it converts to the date format defined in the field (as an field attribute of theSchemaobject) or defined in thedate_formatattribute of the dataset.Dataset now works as an iterator. Use foreach to loop through the lines.Dataset now has adate_out_formatproperty where we define the format in which date-type fields should display their values when converted to string.Fixed the method that calculates the size of fields. Before I was calculating the size of the fields without considering the output formats when converting the fields to string.0.0.4There was an attempt to make the Dataset schemaless. But usage has shown that there is no advantage to using schemaless dataset.Added private methodDataset.__set_schema()to set the schema in the dataset. If the method does not receive a schema, it takes care of instantiating one so that there is always a schema in the dataset.
Package: memdem
MEMDEMMake use of open global elevation data fromTerrain Tilesto create digital elevation models (DEM) on the fly.The memdem project credits thedata source providers. Any use of memdem for redistribution, resale, presentation or publication of the data available from the Terrain Tiles dataset is required to make a similar attribution. Seeherefor more information.Installationmemdem depends onrasterio[s3]morecantileLinux / OSXpip install memdemWindowsnote: Rasterio does not provide official windows wheels, ensureGDALis installed in order to install rasterio dependency.Unofficial wheelsUnofficial rasterio wheels(includes GDAL).Condaconda create -yn memdem python=3.9
conda activate memdem
conda install -c conda-forge gdalOnce GDAL is installed, the environment variableGDAL_VERSIONmay need to be set in order to install rasterio dependency.pip install memdemQuickstartimportrasteriofromrasterio.crs.importCRSimportmemdem# define a bounding boxbounds=(-123.61735447008346,48.91185687803928,-122.74734074899379,49.52797572603976)# create an instance of DEMTilesdemtiles=memdem.DEMTiles(bounds,zoom=10)# behold, a DEM created on the flywithdemtiles.open()asdem:lon,lat=(-123.17911189115098,49.26435101976154)point_xy=rasterio.warp.transform(CRS.from_epsg(4326),dem.crs,[lon],[lat])print(next(dem.sample(zip(*point_xy))))# 20# save DEM to file for later usedemtiles.to_file("path/to/dem.vrt")NotesCoordinate Reference SystemTerrain Tiles are referenced to the EPSG:3857 aka Web Mercator projection. However the vertical
datum (what reference is used for elevation values e.g. WGS84 ellipsoid)may vary depending on the source data. For accurate elevation results, it may be required to use source data with a well-defined vertical datum. For example, SRTM data has vertical datum EGM96.AWS credentialsThe Terrain Tiles dataset is avaiable freely and does not require aws credentials to access. Rasterio uses signed requests by default and may result in an error if it cannot locate your aws credentials. By default, memdem wraps the theDEMTiles.opencontext in arasterio.Env(aws_unsigned=True)context. For operations requiring dataset reads outside of theDEMTiles.opencontext (e.g. when opening a previously saved VRT) ensure you do so within arasterio.Env(aws_unsigned=True)block.
Package: memeapiwrappers
memeapiwrappersWhat is this wrapper for?Its a api wrapper, which has meme images, chuck norris jokes and much more coming in futureOk great How do I use itInmemeapiwrapperswe have two types of functionsasyncandsync. We recommand you usingasyncso it doesnt block your code because its an api request.YOU NEEDaiohttpfor this package, make sure you install itOk ok, where are the examples*Lets get started withasyncfirstimportasynciofrommeme.mainimportasync_get_memeasyncdefmain():very_funny_meme=awaitasync_get_meme()# Two optional argsprint(very_funny_meme)loop=asyncio.get_event_loop()loop.run_until_complete(main())Chuck Norris Exampleimportasynciofromchucknorris.mainimportasync_get_chuck_norris_jokeasyncdefmain():very_funny_meme=awaitasync_get_chuck_norris_joke()# Two optional argsprint(very_funny_meme)loop=asyncio.get_event_loop()loop.run_until_complete(main())Now thesyncfunctionsfrommeme.mainimportget_memeprint(get_meme())# Optional argsfromchucknorris.mainimportget_chuck_norris_jokeprint(get_chuck_norris_joke())# Optional args
Package: memebayes
Bayesian NetworkPublic library for a Bayesian Network in python. This library uses onlyreas dependency. It works as a standalone library and can be used in any python project.It is defined as a classBayesNetworkwhich has the following methods:add_node: Adds a node to the networkedit_node: Edits a node in the networkcompact: Shows a compact representation of the networkdefined: Checks if every node is definedquery: Queries the network for a given nodeInstallationpipinstallmemebayesUsageImporting the libraryfrommemebayesimportBayesNetworkCreating a networknetwork=BayesNetwork(nodes:list)nodesis a list of strings, with the names of the nodes in the network.Adding a nodenetwork.add_node(node:str,parents:list,probabilities:dict)nodeis the name of the node to be added.parentsis a list of strings, with the names of the parents of the node.probabilitiesis a dictionary with the probabilities of the node. The keys are the possible values of the node, and the values are the probabilities of the node given the parents. If the node has no parents, the keys are the possible values of the node, and the values are the probabilities of the node.Editing a nodenetwork.edit_node(node:str,parents:list,probabilities:dict)Compacting the networknetwork.compact()# Returns a string Ej.P(C)P(B|C)P(A|B,C)Checking if the network is definednetwork.defined()# Returns a booleanQuerying the networknetwork.query(query:str)# Returns the probabilities of the node given the evidencequeryis a string with the query to be made. The format isnode|evidence, wherenodeis the name of the node to be queried, andevidenceis a list of strings with the evidence of the query. The format of the evidence isnode=value, wherenodeis the name of the node, andvalueis the value of the node. If there is no evidence, the format isnode.ExamplesfrommemebayesimportBayesNetworknet=BayesNetwork(["B","E","A","J","M"])# Create a network with the nodes B, E, A, J and Mnet.edit_node("B",pt={"B":0.001})# Edit the node B with the probability of being truenet.edit_node("E",pt={"E":0.002})# Edit the node E with the probability of being truenet.edit_node("A",parents=["B","E"],pt={"A|BE":0.95,"A|B-E":0.94,"A|-BE":0.29,"A|-B-E":0.001})# Edit the node A with all the possible probabilities of being true given the parents B and Enet.edit_node("J",parents=["A"],pt={"J|A":0.9,"J|-A":0.5})# Edit the node J with the probability of being true given that A is truenet.edit_node("M",parents=["A"],pt={"M|A":0.7,"M|-A":0.01})# Edit the node M with the probability of being true given that A is trueprint(net.compact())# Print the compact representation of the network (Ej.P(B)P(E)P(A|B,E)P(J|A)P(M|A))print(net.defined())# Check if the network is defined (True)print(net.query("B"))# Query the network for the node B (0.001)print(net.query("B|JM"))# Query the network for the node B given that J and M are true (0.0007)ReferencesThis library is based on the following references:https://en.wikipedia.org/wiki/Bayesian_networkhttp://courses.csail.mit.edu/6.034s/handouts/spring12/bayesnets-pseudocode.pdfhttps://www.cs.cmu.edu/~awm/15781/slides/bayesinf05a.pdf
Package: memecli
Command line wrapper overhttp://memegenerator.netAPI.StatusWork in progress.Install# in some cases you will have to run this as root$pipinstallmemecliOr, you can get the codegitclonehttps://github.com/surrealists/memecli.gitcdmemeclipythonsetup.pyinstallUsagememecli--helpUsage: memecli [OPTIONS] COMMAND [ARGS]...

Command line wrapper over http://memegenerator.net API

Options:
--version  Show the version and exit.
--help     Show this message and exit.

Commands:
content-flag-create             Flag content for removal, for cases of...
meme-create                     Creates a captioned image.
meme-select                     Select an instance by its instance id.
meme-select-by-new              Returns recently created instances, for a...
meme-select-by-popular          Returns the most popular instances for a...
new                             Convenient way of create a new meme
                                instance.
template-search                 Returns a list of search results filtered
                                by...
template-select-by-new          Returns the most recently created
                                generators.
template-select-by-popular      Returns the most popular generators for
                                the...
template-select-by-trending     Returns recently trending generators.
template-select-by-url-name-or-generator-id
                                Returns information about a specific...
template-select-related-by-name
                                Returns generators that are related to a...memeclinew--helpUsage: memecli new [OPTIONS] MEME_ALIAS TOP_TEXT BOTTOM_TEXT

Convenient way of create a new meme instance. To work, need a .memecli.yml
file in the user home directory, with a username, password, and a list of
meme aliases.

Options:
--help  Show this message and exit.LicenseThis work is under a MIT license.