Saravanan666/pypi-org huggingface dataset:
Package: memoria-gui
A simple GUI to generate flashcards for memorizing vocabulary, grammar and phrases of a foreign language.Installpip install memoria-guiUsingmemoriapython gui.pyfrom the terminal produces a GUI with which you choose:a book to draw entries from,which chapters in the book to draw from,which type of entry to draw (vocabulary, grammar or phrases), andin which language to display the entries on the flashcards (English or the foreign language).Grids of flashcards are then generated, spanning all the entries of the chosen type from the chosen source, with the order randomized. Clicking on a flashcard shows its English/foreign language counterpart (or in the case of grammar, the relevant forms).memoriais currently tailored to Italian, but it's easy to drop in another language (it might eventually support Ancient Greek and Latin) - just add new dictionaries with the English and foreign language counterparts.Usingmemoriafor ItalianFor Italian specifically:Clicking on a vocabulary flashcard a second time opens theWordReferencewebsite with a search for the word to obtain its dictionary entry.Clicking on a verb flashcard a second time opens theVirgiliowebsite with a search for the verb to obtain its conjugations in all tenses.Clicking on other grammar or phrase flashcards a second time opens google translate with the Italian version of the entry, so that you can hear it spoken by clicking on the speaker icon there.If you're interested in learning Italian, these are the books I'm using (and the source of flashcard entries in the code). Together I think they should provide a good teaching ofCEFR levelsA1 - C2 of the language (i.e., from beginner to fluent), including a strong understanding of the grammar:New Italian Espresso - Beginner and Pre-intermediate(CEFR level A0 - A1.5) andIntermediate and Advanced(CEFR level A1.5 - B1) - the textbooks and workbooksNuovo Espresso 4, 5, 6(CEFR levels B2, C1, C2) - these books are only in ItalianEnglish Grammar for Students of ItalianItalian Grammar in Practice(covering CEFR levels A1 - B2)Pocket Italian GrammarBackgroundThis package is mostly me wanting a fast way to study Italian and learning how to make GUIs in Python withtkinter. I've only been using Mac OS, so the formatting of the GUIs might be off on Linux or Windows. If you want to use and/or customize the code for your own language and you'd like some help, or if you have any suggestions, feel free to open an issue!memoriais Latin (and Italian!) for 'memory, remembrance'. Hence the Latin phrase 'In memoriam' and the English derivatives 'memorial' and 'memoir'.The logo is a Roman mosaic showing μνημοσύνη (Mnemosyne), the Greek Titan of memory and mother of the nine Muses. μνήμη	is Greek for 'memory, remembrance' and is the origin of the English derivative 'mnemonic'.
Package: memoria-romaaeterna
IntroductionMemoria is a simple application to play Memory (Matching) for up to four players.You can find detailed information including game instructions in theonline documentation.Memoria is hosted onGitLab.LicenseThis program is released under theGNU General Public License (GPL) version 3.See the fileCOPYINGfor more information.InstallationMeson installationTo install Memoria simply run the scriptinstall.shin this directory.pip installationTo download and install Memoria use the following shell command
(make sure thepipcommand is the right one for your platform and Python version):pip install memoria-romaaeternaRunning uninstalledIf you don’t want to install Memoria, simply executerun.pyin this directory.Runtime DependenciesMemoria strongly depends on Gtk+3 and Python 3:Gtk+ 3 (>= 3.16)Python 3 (>= 3.3)PyGObject (>= 3.16)Pycairo (>= 1.10)Special thanks toJoe Hamilton (for his fabuloussimpleaudio package)the Latin students of theVicco-von-Bülow-Gymnasium Falkensee(for being enthusiastic beta testers)
Package: memories
MemoriesDescriptionMemories is an easy to use package that helps to seperate clustered images from files and helps add metadata to files. The documentation is in progress and can be foundhere.Installation$ pip install memoriesHow to Use:There are 8 functions for the time being:open_image: Returns the Image object to you so that it can be passed around to other functionsdivided_crop: Takes 3 inputs, the path to the image, the path where the outful folder should be and the number of images present in the input file. It performs the task of dividing a single image into multiple smaller ones.add_date: Takes input as the image path and the datetime to be added. it will add date when the image was originally taken.bulk_add_date: Same as addDate, except it will add date to all images in a folder. The inputs are the folder path and datetime.save_image: Converts a single image into another formatmake_page: Creates a year book like page in HTMLmake_border: Creates a border around the imagerotate_image: Returns a rotated imageExampleimport memories

# Add meta data to images
memories.add_date("./image-1.jpg", "27/04/2021 12:00:03")
memories.bulk_add_date("./", "27/04/2021 12:00:03")

memories.make_page(["./folder1/image1.png", "./folder2/image2.jpg"], ["CSS", "Larry"], ["SASS", "Another line"], "./save_folder")

image = memories.open_image("./image.png")

memories.divided_crop(image, image_quantity = 6, bgr_value = [255, 255, 255])
# Normal squared borders
memories.make_border(image, "normal", bgr_value = [255, 255, 255], border_dimensions = [100, 100, 100, 100])
# Curved borders
memories.make_border(image, "curved", bgr_value = [255, 255, 255], border_dimensions = [100, 100, 100, 100], radius_dimensions = [100, 100, 100, 100])

memories.save_image("image.png", "path/to/save_folder/file.extention")
# Save multiple images at once
memories.save_image(["img-1.png", "img-1.jpg", "img-2.jpg"], "path/to/save_folder/file.extention")
# Save multiple images as a pdf
memories.save_image(["img-1.png", "img-1.jpg", "img-2.jpg"], "path/to/save_folder/file.pdf")FeaturesCurrent features that are present are:Crop out basic implementationAdd Date and time metadataSave as PDF, PNG, JPGBasic Scrapbook implmentationDocumentationBorderFuture features can also be foundhere:CollageImage Age identifyerLicenseThis software is released under the MIT license, seeLICENSE.txt.
Package: memorious
The solitary and lucid spectator of a multiform, instantaneous and almost intolerably precise world.—Funes the Memorious,
Jorge Luis Borgesmemoriousis a light-weight web scraping toolkit. It supports scrapers that
collect structured or un-structured data. This includes the following use cases:Make crawlers modular and simple tasks re-usableProvide utility functions to do common tasks such as data storage, HTTP session managementIntegrate crawlers with the Aleph and FollowTheMoney ecosystemGet out of your way as much as possibleDesignWhen writing a scraper, you often need to paginate through through an index
page, then download an HTML page for each result and finally parse that page
and insert or update a record in a database.memorioushandles this by managing a set ofcrawlers, each of which
can be composed of multiplestages. Eachstageis implemented using a
Python function, which can be re-used across differentcrawlers.The basic steps of writing a Memorious crawler:Make YAML crawler configuration fileAdd different stagesWrite code for stage operations (optional)Test, rinse, repeatDocumentationThe documentation for Memorious is available atalephdata.github.io/memorious.
Feel free to edit the source files in thedocsfolder and send pull requests for improvements.To build the documentation, inside thedocsfolder runmake htmlYou’ll find the resulting HTML files in /docs/_build/html.
Package: memorised
Aboutmemorisedis a python module containing handypython-memcacheddecorators and utils.
Specifically thememorisedecorator allows you to quickly and simply
add memcache caching to any function or method.InstallationInstallmemorisedusing pip:pip install memorisedOr using the suppliedsetup.py:python setup.py installUsageTo cache a simple unbound function, just include the@memorise()tag to the
function definition (the paranthesis are needed as the decorator needs to be
initialised at the time of binding to handlememorisespecific arguements):from memorised.decorators import memorise

@memorise()
def myfunction():
    return 'hello world'You can do the same for simple instance and class methods, however for most
instance methods, e.g. when caching results for database models, you probably
want to include some form of identity to single out a method call on one
instance from another instance. You can do this by providing a list of one ore
moreparent keys, these are the names of attributes in the parent instance
that you want to be appended to the memcache key:class MyModel:
    id = 1

    @memorise(parent_keys=['id'])
    def get_stats():
        return blah()For other usage examples see the unittests intests.py.
Package: memorize
InstallationTo install memorize, simply use pip:$pipinstallmemorizeor install directly from source to include latest changes:$pipinstallgit+https://github.com/saporitigianni/memorize.gitor clone and then install:$gitclonehttps://github.com/saporitigianni/memorize.git$cdmemorize$python3setup.pyinstallUsageThis class extends the functools.lru_cache functionality to add timed caching and caching aware rate limiting
(e.g. if call results are returned from the cache then that particular call does not affect the rate limit)Constraints:Since a dictionary is used to cache results, the positional and keyword arguments to the function must be hashable (NOT lists, dicts, sets, or any other object that does not define hash())It is very important to use the parenthesis even if empty:@memorize()NOT@memorizeWhen rate limiting, both thecallsandperiodarguments must be provided otherwise an error is raisedDefault Settings:timeout = None (can be int or float)maxsize = None (can be int)typed = False (can be True)calls = None (can be int)period = None (can be int or float)aware = False (can be True)frommemorizeimportmemorize# If you want to use all default settings@memorize()deffib(n):ifn<2:returnnelse:returnfib(n-2)+fib(n-1)# With memorization fib(20) will be run 21 times instead of 21891 times# without memorizationfib(20)# If you want to cache a maximum of 128 calls, cached by different types,# each for 10 seconds use:@memorize(timeout=10,maxsize=128,typed=True)# If you want to implement caching aware rate limiting then use the following:# This will limit to no more than 10 calls for every 5 second period and if a# result is returned from the cache it does not count towards the 10 calls.@memorize(calls=10,period=5,aware=True)ContributingPlease read theCONTRIBUTINGdocument before making changes that you would like adopted in the code.Code of ConductEveryone interacting in thememorizeproject’s codebase, issue
trackers, chat rooms, and mailing lists is expected to follow thePyPA Code of Conduct.:octocat:ETH 0xaD1F09626b9B8e701D5f0F4a237193Df73d3C445BTC 199zsVqCusefv8yjdYQhUQZmLCyh75dqNVLTC LUBqs7VxC43ttPsQuM1jaZFmshKTAU1Rs9
Package: memorize_flashcards
Memorize flashcards provides a python module plus admin shell script
manage personal “courses” in the form of question/answer flashcards.
This can help memorize stuff of any kind- learning for exam in history
class or making your way to learning new language.
The admin tool provides the DB stuff, placing the “cards” files in
place, hashing the, etc, while the python module provides “policy”-
how often each card is shown.A lessonA lesson is one “practice”- for example, going over 30 flashcards,
just before bed time.
The python module “policy.py” is responsible of choosing the cards for
a lesson.A lesson should be comprised of, typically, the cards which the user
know least well. This is the job of the policy- to determine which
cards should play in the comming lesson.It uses the cardsmajorandminornumbers to do this.
A major number of card should tell how far the next lesson for this
card is. For example, major of value ‘1’ means the next lesson should
contain this card, while major value of ‘8’ means you will exersice
this card in 8 lessons.
Theminorvalue of a card tells how well the user known the card.
A value of 1 means “not so well”, while value of 256 means “this card
is well hard coded in the users brain”.
Using these two values the policy should comprise the next lesson.A lesson in act will be showing a card, showing the back side of it
(after pressing some key, or after waiting some amount of time), then
asking the user wheather he knew the card or not.
Then according to policy, update the major/minor values.A classic policySuppose we have a card with major/minor values of 1/2. So in the
comming lesson the card will be shown.
If the user knew the card, a classic policy would push it back to a
distant lesson. How distant? minor+major, meaning 3. This means that
knowing a card doubles the time untill seeing it again. The minor
number is doubled as well, so the new major/manor values are 3/4.
If the user didn’t know the card, the policy would want to show
it next lesson again, and the freequency of showing it should be high,
so in this case the major/minor number would be 2/1.Policies can be added by inheriting from “Policy” and implmementing
fetch_card() and update_card().For example, the classic policy update card function looks somthing
like:def update_card(self, card, value):
        if (card in self.cards) or (card in self.used_pile):
                raise Exception("Illegal state- card must be out of pile and used pile when updated")
        #print "D: card lesson before: {}".format(card.lesson)
        if (value == True):
                card.lesson += card.period
                card.period *= 2
        else: # value == False
                card.lesson += 1
                card.period = 1
        self.used_pile.append(card)
        #print "D: card lesson after: {}".format(card.lesson)A clientClient is a script that uses the policy module and admin tool to
actually present the cards and using the policy and admin tool to
update the DB.A very basic one is currently implemented, which is thememorize-flashcards-konsole-client.
Package: memory-allocator
MemoryAllocatorAn extension class to allocate memory easily with cython.This extension class started as part of theSagesoftware.It provides a single extension classMemoryAllocatorwithcdefmethodsmalloc,calloc,alloarray,realloc,reallocarray,aligned_malloc,aligned_calloc,aligned_allocarray.Memory is freed when the instance ofMemoryAllocatoris deallocated.
On failure to allocate the memory, a proper error is raised.Changelog0.1.3Python 3.11 compatible.0.1.2Provide wheels build by github actions.0.1.1Fixed doctests on 32bit systems.
Package: memorybuffer
memorybufferPython buffer protocol.OverviewProvides routines to implementPython Buffer Protocolin clean Pythoninstead of C extension class.TODO…PyPI record.Documentation.InstallationPrerequisites:Python 3.7 or higherhttps://www.python.org/3.7 is a primary test environment.pip and setuptoolshttps://pypi.org/project/pip/https://pypi.org/project/setuptools/To install run:python -m pip install --upgrade memorybufferDevelopmentPrerequisites:Development is strictly based ontox. To install it run:python -m pip install --upgrade toxVisitdevelopment page.Installation from sources:clone the sources:git clonehttps://github.com/karpierz/memorybuffer.gitmemorybufferand run:python -m pip install ./memorybufferor on development mode:python -m pip install --editable ./memorybufferLicenseCopyright (c) 2012-2022 Adam KarpierzLicensed under the zlib/libpng Licensehttps://opensource.org/licenses/ZlibPlease refer to the accompanying LICENSE file.AuthorsAdam Karpierz <adam@karpierz.net>Changelog0.6.0b1 (2022-09-02)Add support for Python 3.10 and 3.11Drop support for Python 3.6.Copyright year update.Setup update (currently based mainly on pyproject.toml).0.5.0b2 (2020-10-18)Add support for Python 3.9.Drop support for Python 3.5.Setup: fix an improper dependencies versions.Fixed docs setup.Setup general update and cleanup.0.3.0b1 (2019-11-13)Add support for Python 3.8.Drop support for Python 2.Drop support for Python 3.4.Setup update and cleanup.0.2.3a3 (2018-11-08)Drop support for Python 2.6 and 3.0-3.3Update required setuptools version.0.2.3a2 (2018-05-08)Update required setuptools version.Improve and simplify setup and packaging.0.2.2a5 (2018-02-26)Improve and simplify setup and packaging.0.2.2a4 (2018-01-28)Fix a bug and inconsistencies in tox.iniUpdate of README.rst.0.2.2a1 (2018-01-24)Update required Sphinx version.Update doc Sphinx configuration files.0.2.1a2 (2017-11-21)Fix syntax error.Minor improvements.Add trivial example.0.1.1a5 (2017-11-18)Setup improvements.Other minor improvements.0.1.1a4 (2016-01-05)Minor setup improvements.0.1.1a3 (2014-09-25)More PEP8 compliant0.1.1a2 (2014-09-24)Description suplementMinor fixes.0.1.1a1 (2014-09-24)First alpha release.0.0.1a0 (2012-09-23)Initial release.
Package: memory-efficient-transformer-pytorch
faster-transformerSelf-attention Does Not Need $O(n^2)$ MemoryのPytorch実装@misc{rabe2021selfattention,title={Self-attention Does Not Need $O(n^2)$ Memory},author={Markus N. Rabe and Charles Staats},year={2021},eprint={2112.05682},archivePrefix={arXiv},primaryClass={cs.LG}}
Package: memorylru
IntroductionFork ofhttps://github.com/plone/guillotina/tree/master/guillotina/contrib/cacheinto
its own package.This package provides an LRU cache that is constrained by the size, in-memory of the
objects in the cache.frommemorylruimportLRUlru=LRU(1024*1024*50)lru['foo']='bar'
Package: memory-map-manager
memory_map_managerThe Memory Map Manager (MMM) generates code and documentation for embedded
device parameters intended for external interfaces.MotivationEmbedded systems typically run on constrained systems, providing some sort
of access to more powerful machines. A number of parameters can be read (such as
a temperature from a sensor) or written (such as the intended state of a light).
These amount of parameters and complexity can grow and change over the
development cycle of the device. Every parameter needs to not only be available
in the embedded device but also all the external interfaces as well.
If this information is not coordinated it can lead to human error and extra
development time. There are solutions available that helps with that, however,
they typically don't operate under the asymmetric nature of embedded vs host
computer capabilities or end of being very complex requiring large stacks in
order to use.SolutionThe MMM generates simple C code that allows both named parameter access via
typedef structs and byte offset access. Decoding of these parameters are done
on the host, taking advantage of asymmetric computational resources of host vs.
device. The embedded device only needs to expose a way to read or write an
offset and size.InstallationAs this is a "console application" one can use avenvorpipxinstead of pip.Stable versions can be installed with:pip install memory-map-managerGenerating with the MMMInstalling the package comes with a console commandmmm-gen.usage: mmm-gen [-h] [--cfg-path CFG_PATH] [--clean]
               [--loglevel {debug,info,warning,error,fatal,critical}]

optional arguments:
  -h, --help            show this help message and exit
  --cfg-path CFG_PATH, -p CFG_PATH
                        the path to the memory map manager configuration importer.
  --clean, -C           clean the generated directories before generation. be careful!
  --loglevel {debug,info,warning,error,fatal,critical}
                        python logger log level, defaults to "info"There are a number of examples available coming with the generation
configurations and the map configurations.To run the minimal example run:mmm-gen -p examples/minimal/main.yamlThis generates C files, csv files, and the configuration outputs.Writing a Custom MapAlong with the examples of maps there are schemas available that document the
capabilities.There are two files that are needed:ageneration configurationthat
specifies generation information such as input configuration files and output directories. The default file is assumed to bemain.yamlamap configurationthat specifies
the parameters in the map.
Package: memorymarker
memorymarkerTODO: Figure out github actions and add descriptionInstallationYou can installmemorymarkerviapipfromPyPI:pipinstallmemorymarkerUsageTODO: Add minimal usage exampleTo see more examples, see thedocumentation.📖 DocumentationDocumentation🔧InstallationInstallation instructions on how to install this package📖DocumentationA minimal and developing documentation👩‍💻TutorialsTutorials for using this package🎛️API ReferenceAPI reference for this package📚FAQFrequently asked questions💬 Where to ask questionsType📚FAQFAQ🚨Bug ReportsGitHub Issue Tracker🎁Feature Requests & IdeasGitHub Issue Tracker👩‍💻Usage QuestionsGitHub Discussions🗯General DiscussionGitHub Discussions
Package: memory-master-mind
MMM - Memory Master MindMemory training in the terminalInstall with pip:pipinstallmemory-master-mindRun with themmmcommand.Help and Challenges InfoApp HelpStatic Number SequenceTimed Number SequenceMath (Arithmetic)Quotes and VersesPreferencesLinksPowered by thetextualTUI frameworkhttps://github.com/profound-labs/memory-master-mind
Package: memory-monitor-cli
memory-monitor-cliTo install:$pip3installmemory-monitor-cliMonitor the memory with a time window of1minute (m) and refresh each second (60times per minute):$mm-clirun--time-window1--time-unitm--frequency60Streaming to a file...$mm-clirun--time-window1--time-unitm--frequency60--stream-to-filememory-usage.gzand (maybe later) show the stream:$mm-clishow--stream-from-filememory-usage.gz
Package: memory-tr-free
memory-tr-freetranslate for free with async and proxy supportInstallationNot available yetpip install memory-tr-freeValidate installationpython -c "import mymemory_tr; print(mymemory_tr.__version__)"
0.0.1Usageimport asyncio
from mymemory_tr import mymemory_tr

asyncio.get_event_loop().run_until_complete(mymemory_tr('test this and that'))
# '测试这个和那个'AcknowledgmentsThanks to everyone whose code was used