Saravanan666/pypi-org huggingface dataset:
Package: melusine
🎉 **BREAKING** : New major versionMelusine 3.0is available 🎉Free software: Apache Software License 2.0Documentation:maif.github.io/melusineInstallation:pip install melusineTutorials:Discover melusineOverviewDiscover Melusine, a comprehensive email processing library
designed to optimize your email workflow.
Leverage Melusine's advanced features to achieve:Effortless Email Routing: Ensure emails reach their intended destinations with high accuracy.Smart Prioritization: Prioritize urgent emails for timely handling and efficient task management.Snippet Summaries: Extract relevant information from lengthy emails, saving you precious time and effort.Precision Filtering: Eliminate unwanted emails from your inbox, maintaining focus and reducing clutter.Melusine facilitates the integration of deep learning frameworks (HuggingFace, Pytorch, Tensorflow, etc),
deterministic rules (regex, keywords, heuristics) into a full email qualification workflow.Why Choose Melusine ?Melusine stands out with its combination of features and advantages:Pre-packaged Tools: Melusine comes with out-of-the-box features such asSegmenting an email conversation into individual messagesTagging message parts (Email body, signatures, footers, etc)Transferred email handlingStreamlined Execution: Focus on the core email qualification logic
while Melusine handles the boilerplate code, providing debug mode, pipeline execution, code parallelization, and more.Flexible Integrations: Melusine's modular architecture enables seamless integration with various AI frameworks,
ensuring compatibility with your preferred tools.Production ready: Proven in the MAIF production environment,
Melusine provides the robustness and stability you need.Email Segmentation ExempleIn the following example, an email is divided into two distinct messages
separated by a transition pattern.
Each message is then tagged line by line.
This email segmentation can later be leveraged to enhance the performance of machine learning models.Getting startedExplore our comprehensivedocumentationand testedtutorialsto get started.
Or dive into our minimal example to experience Melusine's simplicity and power:frommelusine.dataimportload_email_datafrommelusine.pipelineimportMelusinePipeline# Load an email datasetdf=load_email_data()# Load a pipelinepipeline=MelusinePipeline.from_config("demo_pipeline")# Run the pipelinedf=pipeline.transform(df)The code above executes a default pipeline and returns a qualified email dataset with columns such as:messages: List of individual messages present in each email.emergency_result: Flag to identify urgent emails.With Melusine, you're well-equipped to transform your email handling, streamlining processes, maximizing efficiency,
and enhancing overall productivity.
Package: melvec
melvecA small vector library for pythonInstallation:To install this package typepip install melvecin a console/terminal.Usage:To import the package in your code use:import melvec.To create a 2D-Vector use:melvec.Vec2().To create a 3D-Vector use:melvec.Vec3().For easy access to the vector classes it is recommended import the classes directly with:from melvec import Vec2, Vec3.Example code snippets:Usingimport melvec:import melvec
            
u = melvec.Vec2(10, 2)
v = melvec.Vec2(3, 3)  
w = u + v  # -> Vec(13, 5)

print(u.dot(w))  # -> 140Usingfrom melvec import Vec2, Vec3:from melvec import Vec2, Vec3
            
u = Vec2(10, 2)
v = Vec2(3, 3)  
w = u + v  # -> Vec(13, 5)

print(u.dot(w))  # -> 140
Package: melvil-booklist
MelvilThe Command-line Book Management ToolMelvil is a command line tool for managing books and booklists.Install withpip install booklist-melvilDependencies:pythontyperthefuzzFeatures:Melvil stores your books in a JSON file. Each book contains information about:A titleAn authorA series of tags that describe its genreA state of being readA priority (Position in the list)There are many features that make your life easier:Smooth command line interaction withTyperandInquirerFuzzy searching for book titles for nearly all commands, so you don't have to type the whole title every time. Don't remember a title name? No problem, fuzzy search by tag is available, too.Flags for more common commands allow the user to define how much info they want Melvil to track.Commands:initmakes a new book listaddadds a new bookremovegets rid of a booklistprints out all the books from greatest to least priorityskimlists the attributes of a bookuntagremoves the target tag from the given booklookupsearches by titlecompilesearches by tagdeleteclears the booklistreadingdelivers the book you are reading now, defined as the book with the highest priority in the reading states.nextdelivers the book you want to read next, defined as the book with the highest priority in the "to-read" state.changeChanges one of the book's attributes. Use "change --help" for more.transcribeAdd books from a CSV file in the format of "book title", "book author" to the book list.classifyPrints list of all tags.countPrints list length.
Package: mem
file memorize (under construction)importmemdefadd_str(s0,s1):time.sleep(3)returns0+s1# memorize tool [mem]memorized_func=mem(add_str,# 計算結果をメモ化したい関数"add_str",# 関数識別用の文字列mem_dir="./"# メモの置き場所)ret_str=memorized_func("Hello",", World!!\n")print(ret_str)
Package: memaccess
Python library for Windows giving live access to a program’s memory.Usagememaccessexposes one main class to use for memory inspection:MemoryView. It will request all necessary data from Windows to be
able to access memory of another application. Just pass to the class the
process-id of the application you want to observe:frommemaccessimportMemoryViewview=MemoryView(5555)# Read memory...view.close()It’s safer to use the context-manager variant ofMemoryView:frommemaccessimportMemoryViewwithMemoryView(5555)asview:pass# Read memory...NOTEAccessing another program’s memory requires elevated privileges,
otherwise instantiation ofMemoryViewwill fail.To read content,memaccessexposes thereadfunction. It takes
the number of bytes to read and the address where to start reading.# Read 8 bytes of memory at address 0x01234560view.read(8,0x01234560)For convenience,MemoryViewexposes read methods that convert values
in memory to respective C/C++ types.view.read_int(0x01234560)view.read_float(0x01234564)# ... and many others.You can also write to memory. Note that you have to open theMemoryViewin write-mode:withMemoryView(5555,'rw')asview:view.write_int(33,0x01234560)view.read_int(0x01234564)Please inspect theMemoryViewclass for details on all of those
functions.ExceptionsSome exceptions are raised due to internal Windows API errors and show
an error code.>>> from memaccess import MemoryView
>>> MemoryView(5555)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  ...
RuntimeError: Can't open process with pid 5555, error code 87You can read up on those error codes here:https://msdn.microsoft.com/de-de/library/windows/desktop/ms681381(v=vs.85).aspx
Package: memacs
This Python framework converts data from various sources to Org mode format
which may then included in Org mode agenda (calendar). This way, you get a 360-degree-view of your
digital life.Each Memacs module converts a different input format into Org mode files.Target group: users of Emacs Org mode who are able to use command line toolsHosted and documented on github:https://github.com/novoid/memacs
Package: memail
# cos518Course Project for COS518 - Advanced Computer SystemsRequired libraries------------------|Library||:-----:||[numpy](http://www.numpy.org/)||[sklearn](http://scikit-learn.org/stable/)||[nltk](http://www.nltk.org/)||[gensim](https://radimrehurek.com/gensim/)|The easiest way to install the above is by using [anaconda](https://www.continuum.io/why-anaconda), and then lastly``pip install --upgrade gensim``
Package: memair
OverviewSDK for simple interaction with the Memair APIsInteractive NotebookExplore this package in anInteractive NotebookHosted bybinderInstallationmemairis available on PyPIhttp://pypi.python.org/pypi/memairInstall viapip$ pip install memairOr viaeasy_install$ easy_install memairOr directly frommemair’sgit repo$ git clone git://github.com/memair/memair-python-sdk.git
$ cd memair
$ python setup.py installBasic usageGenerate a temporary access tokenValidate GraphQL with GraphiQL>>> from memair import Memair
>>> api_key = '0000000000000000000000000000000000000000000000000000000000000000'
>>> user = Memair(api_key)
>>> latest_location = user.query('''
        {
            Locations(first: 1, order: timestamp_desc) {
            lat
            lon
            timestamp
          }
        }
    ''')
>>> latest_location['data']['Locations'][0]
{'lat': 42.909056, 'lon': -74.572508, 'timestamp': '2018-07-27T22:27:21Z'}Memair DNS toolsThis package also includes a method to check if Memair DNS is blocked on specific dates.>>> from memair import is_dns_blocked
>>> from datetime import date
>>> is_dns_blocked(date(2019,1,9))
True
>>> is_dns_blocked(date(2019,1,10))
FalseRunning Test$ python tests.pyPython compatibilityDeveloped for Python 3. May work but not tested in Python 2.
Package: membank
membankPython library for storing data in persistent memory (sqlite, postgresql, berkeley db)goalsProvide interface to database storage that automates heavy lifting of database setup, migration, table definition, query construction.quick introadd items to persistent storageimportdataclassesasdata# Python standard libraryfrommembankimportLoadMemory@data.dataclassclassDog():breed:strcolor:str="black"weight:float=0data:dict=data.field(default_factory=dict)picture:bytes=b''aliases:list=data.field(default_factory=list)@data.dataclassclassDogWithID():id:str=data.field(default=None,metadata={"key":True})breed:strcolor:str="black"weight:float=0data:dict=data.field(default_factory=dict)picture:bytes=b''alive:bool=Truememory=LoadMemory()# defaults to sqlite memorymemory.put(Dog('Puli'))# stores object into databasedog=memory.get.dog()# retrieves first object foundassertdog.breed=='Puli'dog.color="white"memory.put(dog)# be carefull you store another dogdog=memory.put(DogWithID("AB1234","Puli"))dog=memory.get.dogwithid(id="AB1234")dog.color="white"memory.put(dog)# now you update existing dogretrieve those aftermemory=LoadMemory()# to make this work in new process, don't use sqlite memorydog=memory.get.dog()# get first found or Noneassertdog.color=='black'dogs=memory.get("dog")# always returns list (empty or with items)assertlen(dogs)>=0editing returned objectsdog=memory.get.dog()dog.breed='Labdrador'memory.put(dog)# stores edited object backfilter objectsdog=memory.get.dog(breed='Labdrador')assertdog.breed=='Labrador'Known issuesreturn class is stored(pickled) into underlying database table with reference to the module to load it back. If module name or class name is changed, membank won't always be able to load previous data as object pointer could be missing
Package: membernator
membernatoris a tool that can be used to scan membership cards and establish if
they're valid or not against a CSV database.DependenciesThis program is written in Python 3. You will need to install these dependencies
to runmembernatorproperly:python3pygamedocoptInstallationDebianmembernatoris packaged in Debian! You can install it using:$ sudo apt install membernatorWith setup.pyYou can installmembernatorlike any other python program with the help ofsetuptools:$ python3 setup.py installWith pipYou can installmembernatorby downloading it from PyPi:$ pip3 install membernatorInternationalisationMembernator supports internationalisation. If you wish to add new locales, you
can use the files in thelocalesdirectory.Current locales supported are:English (default)FrenchNote that internationalisation is only supported if you install the Debian
package.UsageUsage:
    membernator [options] --database FILE
    membernator (-h | --help)
    membernator --version

Options:
    -h  --help       Shows the help screen
    --version        Outputs version information
    --database FILE  Path to the CSV database
    --id_col ID      "id" column in the CSV database. [default: ID]
    --name_col NAME  "name" column in the CSV database. [default: NAME]
    --time SEC       Delay in secs between scans. [default: 2.5]
    --width WIDTH    Width in pixels. Use 0 for fullscreen. [default: 800]
    --height HEIGHT  Height in pixels. Use 0 for fullscreen. [default: 480]
    --logfile LOG    Path to the logfile
Package: members
INSTALLATIONExample install, using VirtualEnv:# install/use python virtual environment
virtualenv ~/virtenv_scratch --no-site-packages

# activate the virtual environment
source ~/virtenv_scratch/bin/activate

# upgrade pip in the new virtenv
pip install -U pip setuptools

# install this package in DEVELOPMENT mode
python setup.py develop

# or simply install
# python setup.py installCONFIGURATIONExample configuration, eg at~/.members:mailman2:
    base_url: http://some.domain.com/mailman2
    lists:
        announce-list:
            user: bla@bla.com
            password: asdfvi5f211
        memo-list:
            user: bla@bla.com
            password: dasdf458@1j
        dept-list:

github:
    user: kejbaly2
    token: FGIOUSODIUGSDGJ
    # password: ********
    user_attrs: [email, bio, url]

orgchart:
    base_url: http://some.domain.com/orgchart3USAGEMailman2Example usage, for Mailman2:members mailman2 dept-listOverriding username and password:members mailman2 dept-list -u other -p SoM3P@Ss!OrgChart 3Example usage, for OrgChart 3:members orgchart3 teamlead cwardBUILD DOCSExample scenario for building docs with sphinx:cd docs
make htmlTESTINGTesting is py.test based. Run with:py.test tests/ -vDEVELOPMENTInstall the supplied githooks; eg,ln -s ~/repos/members/_githooks/commit-msg ~/repos/members/.git/hooks/commit-msg
ln -s ~/repos/members/_githooks/pre-commit ~/repos/members/.git/hooks/pre-commit
Package: membersuite-api-client
[![Build Status](https://travis-ci.org/AASHE/python-membersuite-api-client.svg?branch=master)](https://travis-ci.org/AASHE/python-membersuite-api-client) [![Coverage Status](https://coveralls.io/repos/github/AASHE/python-membersuite-api-client/badge.svg?branch=master)](https://coveralls.io/github/AASHE/python-membersuite-api-client?branch=master) [![Issue Count](https://codeclimate.com/github/AASHE/python-membersuite-api-client/badges/issue_count.svg)](https://codeclimate.com/github/AASHE/python-membersuite-api-client/issues) [![Requirements Status](https://requires.io/github/AASHE/python-membersuite-api-client/requirements.svg?branch=master)](https://requires.io/github/AASHE/python-membersuite-api-client/requirements/?branch=master)# python-membersuite-api-client
A python interface to the MemberSuite API## InstallationInstall from PyPI.`pip installmembersuite-api-client`## MemberSuite ConfigurationIn your MemberSuite account, you will need to create a dedicated API console
user. Ensure that API access is enabled for your MemberSuite account, and
also check the box for “API User” for this new user account.Create a keypair for this user via the console and save the credentials
generated somewhere secure (they cannot be retrieved later if lost)## Usagefrom membersuite_api_client.client import ConciergeClientclient = ConciergeClient(access_key=MS_ACCESS_KEY,
secret_key=MS_SECRET_KEY,
association_id=MS_ASSOCIATION_ID)To authenticate and receive a session ID:client.request_session()
print client.session_idTo take advantage of a service, for examplesubscriptions:service = SubscriptionService(self.client)
subscription_list = service.get_subscriptions(org_id=1)## Running testsTo run all tests:$ nosetestsTo run specific tests, load them by module. For example:$ python -m membersuite_api_client.tests.test_subscriptions## Contributing and ExtendingLooking to contribute? The best place to start is in the code base. Notice how
we created modules for each MemberSuite object, likeorganizations.Each module containsservices.pyandmodels.pyfiles.Your “models” are simply python representations of the MemberSuite objects.Your “services” provide interfaces to those models in MemberSuite. This is
where objects are retrieved from MemberSuite and converted to your models for
use in a python app. It is recommended that the services be classes and if
you defineresult_to_modelsandms_object_to_modelmethods on the class
you can use the ChunkQueryMixin to make large queries.### NuanceThis can now be used to make additional calls using the methods included in
the WSDL from MemberSuite. For documentation on available methods and their
usage, seehttp://api.docs.membersuite.com/Use request_session() as a model for constructing the headers for
your own functions in your app that follow this method:Call client.construct_concierge_header(url) to generate a new header element, using your method’s URL as an argument.Call client.service.method_name(_soapheaders=[concierge_request_header], method arguments)Return any relevant data out of the response object*IMPORTANT NOTE: In constructing headers, SessionId must appear first.*
Package: membrain-seg
MemBrain-SegMembrain-Seg is a Python project developed byteamtomofor membrane segmentation in 3D for cryo-electron tomography (cryo-ET). This tool aims to provide researchers with an efficient and reliable method for segmenting membranes in 3D microscopic images. Membrain-Seg is currently under early development, so we may make breaking changes between releases.Membrain-Seg is currently under early development, so we may make breaking changes between releases.OverviewMemBrain-seg is a practical tool for membrane segmentation in cryo-electron tomograms. It's built on the U-Net architecture and makes use of a pre-trained model for efficient performance.
The U-Net architecture and training parameters are largely inspired by nnUNet1.Our current best model is available for downloadhere. Please let us know how it works for you.
If the given model does not work properly, you may want to try one of our previous versions:Other (older) model versions:v9 -- best model until 10th Aug 2023v9b -- model for non-denoised data until 10th Aug 2023If you wish, you can also train a new model using your own data, or combine it with our (soon to come!) publicly-available dataset.To enhance segmentation, MemBrain-seg includes preprocessing functions. These help to adjust your tomograms so they're similar to the data our network was trained on, making the process smoother and more efficient.Explore MemBrain-seg, use it for your needs, and let us know how it works for you!Preliminarydocumentationis available, but far from perfect. Please let us know if you encounter any issues, and we are more than happy to help (and get feedback what does not work yet).[1] Isensee, F., Jaeger, P.F., Kohl, S.A.A., Petersen, J., Maier-Hein, K.H., 2021. nnU-Net: a self-configuring method for deep learning-based biomedical image segmentation. Nature Methods 18, 203-211. https://doi.org/10.1038/s41592-020-01008-zInstallationFor detailed installation instructions, please lookhere.FeaturesSegmentationSegmenting the membranes in your tomograms is the main feature of this repository.
Please find more detailed instructionshere.PreprocessingCurrently, we provide the following twopreprocessingoptions:Pixel size matching: Rescale your tomogram to match the training pixel sizesFourier amplitude matching: Scale Fourier components to match the "style" of different tomogramsDeconvolution: denoises the tomogram by applying the deconvolution filter from WarpFor more information, see thePreprocessingsubsection.Model trainingIt is also possible to use this package to train your own model. Instructions can be foundhere.Patch annotationsIn case you would like to train a model that works better for your tomograms, it may be beneficial to add some more patches from your tomograms to the training dataset.
Recommendations on how to to this can be foundhere.
Package: membrane
membrane.py 🦠AFlaskarg-parser & splitter to ensure wanted data gets through, unwanted data stays out, and required data shows up.Compatible withFlask-RESTful. 👍Basic Usage 🐍fromflaskimportFlaskapp=Flask(__name__)@app.route('/')defroute_handler():return"No args~!"Above we see a basicFlaskapplication with a root API handler. No query options are yet passed to our root.Let's say we wanted to handle the query parameter?limit=0in the request handler. We can use membrane to do this.fromflaskimportFlask,jsonifyfrommembraneimportmembraneapp=Flask(__name__)@app.route('/')@membrane({'limit':int})defroute_handler(microbe):'''Here microbe should be either an empty dict: {} or dict: {"limit": ?}'''returnjsonify(microbe)Defining Membranes 🔬Themembrane, a wrapper function, can take multiple layers of typedictwhich will act as a filter for the: 1) query parameters; 2) body; and 3) headers passed to the request handler. The route_handler will take these filtered dicts as*args.The basic structure is as follows:simple_membrane={"limit":int}complex_membrane={"other_parameter":{"type":lambdax:int(x),"options":(1,2,3,),"default":1,"required":False,"location":"params"}}In the simple_membrane, we want to take limit from either the params, body, or headers and convert it to an int (or verify that it is of type int). We're also allowed to use custom functions to handle conversions here.The complex_membrane is different in that it's a dict with additional options.type: any callable function or class.options: a tuple of accepted values.default: if not provided, use this as a default. If you need this value to be generated at the time of parsing, provide a callable function that returns the proper value.required: should the server throw an error if this value is not provided?location: where in the request should we search for this value: ("params", "body", "headers", "files").To use multiple layers for a route handler, simply list them out.@app.route('/')@membrane(simple_membrane,complex_membrane)defroute_handler(simple_microbe,complex_microbe):returnjsonify([simple_microbe,complex_microbe])Error Handling ⚠️Exported from membrane are exceptions:RequiredFieldError,NotAnOptionError,TypeConversionError.You can handle these errors yourself or use our default error handler.frommembraneimporterror_handlerapp=Flask(__name__)error_handler(app)Otherwise you can handle these errors however you like.