Saravanan666/pypi-org huggingface dataset:
Package: genxword
A crossword generatorDescriptionGenxword is a crossword generator written in Python.When you install genxword, you will have two programs,genxword-gtk,
which has a graphical user interface, and genxword, which runs from the
command line.Both programs create a crossword from a list of words and
clues. You can save the crossword, with clues, as a pdf file, or you can
save the empty grid and key in png and/or svg format, together with the
word bank and clues in a text file.FeaturesThe crossword can be saved, with clues, as a pdf file, or the empty
grid and key can be saved in png and/or svg format, together with the
word bank and clues in a text file.The crossword can be recalculated multiple times - with the option to
increase the grid size at each stage.A dictionary file can be used as the word list. A certain amount of
words (default 50) will be randomly selected from the file and used
to make the crossword.When editing the word list, there is an option to sort it, from the
shortest to the longest word, and remove non-alphabetic characters.Multiple languages, including right-to-left languages, such as Hebrew
and Arabic, are now supported.UsePlease read thewikifor
information about how to use genxword.InstallationTo install genxword (addsudoto the command, or run as root,
if you are using Linux):pip3 install genxwordDependenciesGenxword depends on pycairo (python-cairo), pygobject (python-gobject or python-gi),
python-gi-cairo (if you are using a Debian-based system), pango (gir1.2-pango-1.0),
gtksourceview3 (gir1.2-gtksource-3.0) and gettext.These dependencies can easily be installed on Linux by using your package manager,
and with most distributions, they will already be installed.Windows users can download these dependencies fromhereWhen installing python-gobject, you also need to install (check the boxes for)
gtk3, pango, gdk-pixbuf and gtksourceview3.AuthorsThis program has been developed by David Whitlock, and it is based on a
program originally written by Bryan Helmig.TranslatorsMany thanks to the following people, who have kindly provided translations for genxword:Miguel Anxo Bouzada (Catalan, Spanish and Galician), Koen Wybo (Dutch), Pinkvana Thaworn (Thai)
and me (French).
Package: geny
genyAn extendable file generatorgenyInstallationExtending the CLIDependenciesTo DoPull requestsLICENSEInstallationInstall viapip:pipinstallgenyAfter installation, the CLI will expose the binary with the name:genyExtending the CLICurrently, there are two main ways of extending the functionality of the CLI:Adding your own commands/pluginsOverriding the provided resource templatesIncluding your own commandsIf you would like to extend the functionality of this CLI, you can include your ownplugins/commandsby
setting an environment variable:GENY_PLUGINS. Simply set this variable to the path where your plugins are.Plugin commands are auto-discovered if they are placed under the plugins directory,
but please be sure to do the following for this to work:Name your package and click command the same. That is, a package calledget, for example, should define agetcommand.Place the command definition within the package'smain.pymodule. For example:# get/main.pyimportclick@click.command()@click.pass_contextdefget(ctx):passSub-commands should be added to the top-most command group in the package'smain.pymodule.# get/main.pyimportclick@click.group()# <- group@click.pass_contextdefget(ctx):pass@click.command()@click.pass_contextdeffoo(ctx):passget.add_command(foo)Access your commands via your top-most command group.geny get fooNOTE:If you would like to skip a plugin/command from being auto-discovered, simply rename the package by either
prepending or appending any number of underscores (_). Any code contained within the package will be ignored.Overriding the templatesThe flag--templates-dircan be used to configure an additional path wherein the CLI can look for resource templates.
Alternatively, you can use the environment variableGENY_TEMPLATES_DIRfor the same purpose.DevelopmentInstall from source:git clone https://github.com/oleoneto/geny.git
cd geny
pip install --editable .DependenciesCheck outpyproject.tomlfor all installation dependencies.To DoCheck out our open issues.Pull requestsFound a bug? See a typo? Have an idea for new command?
Feel free to submit a pull request with your contributions. They are much welcome and appreciated.LICENSEgenyisBSD Licensed.
Package: genyal
Genyal: The cheerful genetic algorithm frameworkThis work is licensed under aCreative Commons Attribution 4.0 International LicenseGenyalis a genetic algorithm framework aimed to be as simple to use as it can be.
Evolution is natural, so using evolutionary algorithms should feel natural as well.One of the main benefits of evolutionary programming is making it simple to solve complicated
problems, and that's something that most implementations of this kind of algorithms seems to forget.
You'll find either, very simple implementations of genetic algorithms from scratch, or full fledged
libraries that are, by no means, something that someone with little experience in the field of
evolutionary programming can easily use; nothing in between.Genyalis that missing "in between", by providing a simple interface so users new to the topic
can learn and use it without need of being experts, and flexible enough so that people can adapt it
to more sophisticated scenarios.UsageJust like using it, installingGenyalshould be a piece of cake (great, now I want cake).
To do so, you can get it directly from PyPi or, with pip:pipinstallgenyalExample: Guessing a wordLet's check a very simple example.
A program to guess a given word.First, we need a way to create the individuals of the population, in this case, each individual will
represent a word, and each gene of the individual will be a letter (lowercase).
For this we can implement a generator function like:importrandomimportstringfromgenyal.genotypeimportGeneFactoryfromgenyal.engineimportGenyalEnginedefrandom_char():returnrandom.choice(string.ascii_lowercase)gene_factory=GeneFactory[str]()gene_factory.generator=random_char# This is how the engine will select the fittest individualsdeffitness_fun(word:list[str])->float:returnsum([word[i]=="owo"[i]foriinrange(0,3)])# This is the condition to stop the evolutiondeftarget(genyal_engine:GenyalEngine)->bool:return"".join(genyal_engine.fittest.genes)=="owo"engine=GenyalEngine(fitness_function=fitness_fun,terminating_function=target)# We create an initial population of 16 words (Individuals) of 3 characters (genes)# using our previously defined gene factory.engine.create_population(16,3,gene_factory)engine.evolve()print(f"Found solution in{engine.generation}generations")print(f"Fittest individual:\"{''.join(engine.fittest.genes)}\"with fitness: "f"{engine.fittest.fitness}")If you run the code it will print something like:Found solution in 543 generations
Fittest individual: "owo" with fitness: 3You can find the explanation of this code, along with other examples, at the project'swiki
Package: geny-gmtool
Genymotion Gmtool for PythonUsage:free versionget devices from genymotionstart devices from genymotionstop device from genymotionUsageGet devices from genymotionStatus contains three (running, off, all)defget_list_devices_running(status:GenyStatus=GenyStatus.ALL)->List[GenymotionDeviceModel]Start device from genymotionParam:device_name:  the name of devicedefstart_device_name(device_name:str)->int""":param device_name: the device name , must confirm if it's online:return return 0 means start successfully, -1 means not"""Stop device from genymotionParam:device_namedefstop_device_name(device_name:str)->int""":param device_name: the device name , must confirm if it's online:return return 0 means stop successfully, -1 means not"""
Package: genzshcomp
Automatic generate to Zsh Completion Function from
Python’s Option Parser Modules.Now, It corresponds toargparsemodule andoptparsemodule.I write this module because I want to be createdgrincommand’s
Zsh Completion Function.Installationused to pip:$ pip install genzshcompused to easy_install:$ easy_install genzshcompRequirementsPython3.5+Usageshow example dir…from code of option parser objectbasic usage:## gen.py
from genzshcomp import CompletionGenerator
from optparse import OptionParser
parser = OptionParser()
generator = CompletionGenerator(command_name, parser)
print generator.get()and zsh completion setups:$ python gen.py > ~/.zsh/comp/_command
$ echo "fpath=(~/.zsh/comp/ $fpath)" >> ~/.zshrc
$ echo "autoload -U ~/.zsh/comp/*(:t)" >> ~/.zshrc
$ echo "autoload -Uz compinit" >> ~/.zshrcfrom help-stringsbasic usage and zsh completion setups (ex.pep8 command):$ pep8 --help > pep8help.txt
$ genzshcomp pep8help.txt > ~/.zsh/comp/_pep8
$ echo "fpath=(~/.zsh/comp/ $fpath)" >> ~/.zshrc
$ echo "autoload -U ~/.zsh/comp/*(:t)" >> ~/.zshrc
$ echo "autoload -Uz compinit" >> ~/.zshrcusing shell pipe:$ pep8 --help | genzshcomp > ~/.zsh/comp/_pep8
# As follows...Support Bash Completionusing shell pipe:$ pep8 --help | genzshcomp -f bash > /etc/bash_completion.d/pep8
$ bashSupport commandsgrin/grind(grin –help)gunicorn(gunicorn –help)markdown2(markdown2 –help)paver(paver –help)pep8(pep8 –help)pylint(pylint –long-help)and more…
Package: genz-tokenize
Genz TokenizeUsing for tokenizefromgenz_tokenizeimportTokenize# using vocab from libtokenize=Tokenize()print(tokenize('sinh_viên công_nghệ','hello',max_len=10,padding=True,truncation=True))# {'input_ids': [1, 770, 1444, 2, 2, 30469, 2, 0, 0, 0], 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 0, 0, 0], 'sequence_id': [None, 0, 0, None, None, 1, None]}print(tokenize.decode([1,770,2]))# 
 sinh_viên 
# from your vocabtokenize=Tokenize.fromFile('vocab.txt','bpe.codes')Preprocessing datafromgenz_tokenize.preprocessimportremove_punctuations,convert_unicode,remove_emoji,vncore_tokenizeModel1. Seq2Seq with Bahdanau Attention
2. Transformer classification
3. Transformer
4. BERTTrainerfromgenz_tokenize.base_model.utilsimportConfigfromgenz_tokenize.base_model.modelsimportSeq2Seq,Transformer,TransformerClassificationfromgenz_tokenize.base_model.trainingimportTrainArgument,Trainer# create config hyper parameterconfig=Config()config.vocab_size=100config.target_vocab_size=120config.units=16config.maxlen=20# initial modelmodel=Seq2Seq(config)x=tf.zeros(shape=(10,config.maxlen))y=tf.zeros(shape=(10,config.maxlen))# create datasetBUFFER_SIZE=len(x)dataset_train=tf.data.Dataset.from_tensor_slices((x,y))dataset_train=dataset_train.shuffle(BUFFER_SIZE)dataset_train=dataset_train.batch(2)dataset_train=dataset_train.prefetch(tf.data.experimental.AUTOTUNE)args=TrainArgument(batch_size=2,epochs=2)trainer=Trainer(model=model,args=args,data_train=dataset_train)trainer.train()fromgenz_tokenize.models.bertimportDataCollectionfromgenz_tokenize.models.bert.trainingimportTrainArg,Trainnerfromgenz_tokenize.models.bert.robertaimportRoBertaClassification,RobertaConfigimporttensorflowastfx=tf.zeros(shape=(10,10),dtype=tf.int32)mask=tf.zeros(shape=(10,10),dtype=tf.int32)y=tf.zeros(shape=(10,2),dtype=tf.int32)dataset=DataCollection(input_ids=x,attention_mask=mask,token_type_ids=None,dec_input_ids=None,dec_attention_mask=None,dec_token_type_ids=None,y=y)tf_dataset=dataset.to_tf_dataset(batch_size=2)config=RobertaConfig()config.num_class=2model=RoBertaQAEncoderDecoder(config)arg=TrainArg(epochs=2,batch_size=2,learning_rate=1e-2)trainer=Trainner(model,arg,tf_dataset)trainer.train()
Package: geo3d
geo3dA python package for performing geometric calculations in 3D.
It allows tofind coordinate system transformations between framestransform points and vectorsexpress points and vectors in different framescreate frames from primary and secondary axes vectorsalign two point groups by minimizing point-to-point distancesfit planes to pointsRequires Python 3.7 or up .InstallationTo install the module and its core requirements, runpipinstall--user-e.within the base directory.To install all requirements, including the ones for unit testing and documentation.pipinstall--user-e.[dev]UsageInstructions on basic usage can be found in the jupyter notebook in/docs,
which are also deployed tohimbeles.github.io/geo3d.TestingUnit tests can be run usingpytest-sin package root.If a coverage report should be generated, runpython-mcoveragerun-mpytestBuilding the docsThe documentation can be built from the.ipynbdocuments in the/docsfolder by runningmakehtml
Package: geo3dfeatures
Extract geometry features from 3D point cloudsContentThe project contains the following folders:geo3dfeaturescontains source codedocscontains some mardown files for documentation purpose and
imagesexamplescontains some Jupyter notebooks for describing datatests;pytestis used to launch several tests from this folderAdditionally, running the code may generate extra subdirectories in a chosen
data repository (./data, by default).How to installThis projects runs with Python3, every dependencies are managed
throughpoetry.Installation from source$ git clone ssh://git@git.oslandia.net:10022/Oslandia-data/geo3dfeatures.git
$ cd geo3dfeatures
$ virtualenv -p /usr/bin/python3 venv
$ source venv/bin/activate
(venv)$ poetry installContributionSeeCONTRIBUTING.md.Run commandsIn order to get the available program commands, consider the program help (geo3d -h):usage: geo3d [-h] {info,sample,index,featurize,cluster,train,predict} ...

Geo3dfeatures framework for 3D semantic analysis

positional arguments:
  {info,sample,index,featurize,cluster,train,predict}
    info                Describe an input .las file
    sample              Extract a sample of a .las file
    index               Index a point cloud file and serialize it
    featurize           Extract the geometric feature associated to 3D points
    cluster             Cluster a set of 3D points with a k-means algorithm
    train               Train a semantic segmentation model
    predict             Predict 3D point semantic class starting from a
                        trained model

optional arguments:
  -h, --help            show this help message and exitAny further CLI documentation may be printed withgeo3d <command> -h.DocumentationSome documentation is available, that describes the set of considered geometric
features, the fixtures (i.e.dummy datasets) used for test purpose and a
practical pipeline use case:Feature setTest fixturesCommand pipelineExamplesThe following example has been generated starting from
aCANUPOdataset (filescene.xyz, with 500k points, 50 neighbors and all the features):Oslandia – 2019-2020
Package: geo58
Geo58Yet another short-link specification for geo-coordinates.Key Featuresuses base-58 encodingcan be as short as 8 characters, mostly 9 charactersmaximum length of 10 charactersresolves to about 1.1m accuracygeocoordinates that are close, look similarcan include a zoom level of a map (20-5)Base-58 encodingBase-58 encodinguses 58 alphanumerical characters of the alphabet plus 9 digits.
Characters that look similar ('0', 'O', 'I', 'l') are omitted.
This allows for manual copying of data with little potential for ambiguity.8-10 characters shortThe encoding is done in the followin schema:[Zoom 4bit][joined [Lat 25bit][Lon 26bit]]Zoom: beeing an optional parameter for a possible viewport (see below).posLat: is the latitude (mapped from [-90,90] to [0, 180]).posLon: is the longitude (mapped from [-180,180] to [0, 360]).The last 51 bit are 'intervoven' to generate a bit-sequence with least significant bits to the right.
This allows the generation of short-strings that are similar to each other if they are close to one another.Link similarityThe following 3 links, refer to cafes in Heidelberg, which are only ~25m apart:https://yosm.at/NBiwwcnfq;amenity=cafehttps://yosm.at/NBiwwcnuw;amenity=cafehttps://yosm.at/NBiwwcnZc;amenity=cafeZoom level (can be) included4 bit of the short-string are used to encode the zoom level of a viewport. This can be used to
hint at the size of the object that is being referred to.
The zoom level is pre-fixed to the bit-sequence. It is also 'inverted' to allow zoom level 20
to be represented as zero and 19 as one. Zomm level 5 would be using 4 bits.As the zoom level is pre-fixed, zoom level 20 does not 'consume' any bit-bandwidth, resulting in a
short-string being as short as possible.CreditThis format came to be during the creation of a short-link format forYellowOSM.YellowOSM is supported byNetIdee.
Package: geo-adjacency
Geo-AdjacencyPiprepositoryFulldocumentationInstallationIt's recommended to use a virtual environment to install this tool, since its dependencies may
require different versions than what is installed on your system.pipRecommended installation is withpip:python -m pip install geo-adjacencyBuild from sourceYou must have Python <3.13,>=3.9 installed.$ git clone git@github.com:asmyth01/geo-adjacency.git
$ cd geo-adjacency
$ poetry installOr withbuild.$ git clone git@github.com:asmyth01/geo-adjacency.git
$ cd geo-adjacency
$ python -m buildExample UsageSee thedocsfor details.Load the data. geo-adjacency expects you to provide your data as Shapely geometries. You will provide three lists: source_geoemtries, target_geometries, and obstacle_geometries. What we are analyzing is which of the source geometries are adjacent to which of the target geometries. Obstacles can prevent a source and target from being adjacent, but they do not participate in the adjacency dictionary.Create an AdjacencyEngine. In this case, we'll load the sample data which is available onGithub <https://github.com/asmyth01/geo-adjacency/>_.s,t,o=load_test_geoms("../tests/sample_data")engine=AdjacencyEngine(s,t,o,True)Run the analysisoutput=engine.get_adjacency_dict()# defaultdict(<class 'list'>, {0: [1, 2], 1: [1], 2: [1], 3: [2], 6: [1], 7: [1]})The output is a dictionary. Keys are the indices of source geometries in the input list, and values are a list of indices of adjacent target geometries in the input list.You can visualize the output with a handy built-in method which uses pyplot.engine.plot_adjacency_dict(). (Source geoms are grey, targets are blue, obstacles are red. Linkages are green.You probably will want to match the adjacency dictionary back to the original data so that you can do something cool with it.forsource_i,target_i_listinoutput.items():source_geom=source_geometries[source_i]target_geoms=[target_geometries[i]foriintarget_i_list]
Package: geoakima
Akima - This package allows to perform an Akima interpolationThis package allows to perform an interpolation with the Akima method specially adapted to fill the geographic dataSysteme recquiredgfortran 7python3-devinstallation with pippip install geoakimaTrying Akima3D>>> import geoakima.geoakima as ga
>>> akima=ga.geoakima()
>>> akima.read()#FileName.txt or .csv
>>>akima.Akima()
>>>akima.output()By default the file containing the data to Interpolated is called "DataTrain.txt",
it is placed in the sources.
Here are its formatting (4 first lines)DataTain.txt20111021-0001	153901.098	2560282.065	1.256
20111021-0002	153901.091	2560282.527	1.239
20111021-0003	153900.996	2560283.208	1.249
20111021-0004	153900.93	2560284.064	1.288The script "Example.py" and the file "FileName.txt"
must be placed in the working folder,
not forgetting to pass the name of the data file
to the read function "akima.read("FileName.txt")".code based on :akima.new.f,  tripack.fHiroshi Akima
U.S. Department of Commerce, NTIA/ITS
Version of 1995/05Robert J. Renka
Dept. of Computer Science
Univ. of North Texas
11/12/94
Package: geoalgo
geoalgo is a Django app to conduct web-based polls. For each question,
visitors can choose between a fixed number of answers.Detailed documentation is in the “docs” directory.Quick startAdd “polls” to your INSTALLED_APPS setting like this:INSTALLED_APPS = [
    ...
    'geoalgo',
]Include the polls URLconf in your project urls.py like this:path('polls/', include('polls.urls')),Runpython manage.py migrateto create the geoalgo models.Start the development server and visithttp://127.0.0.1:8000/admin/to create a poll (you’ll need the Admin app enabled).Visithttp://127.0.0.1:8000/polls/to participate in the geoalgo.
Package: geoana
getting_started|connecting|installing|license|documentation|geoanageoanais a collection of (mostly) analytic functions in geophysics. We take an object oriented
approach with the aim of having users be able to readily interact with the functions usingJupyterGetting startedIf you do not already have python installed, we recommend downloading and installing it throughanacondainstallinggeoanaBrowse thegalleryfor ideas and example usageRead thedocumentationfor more information on the library and what it can doConnecting with the communitygeoana is a part of the largerSimPEGecosystem. There are several avenues for connecting:a discourse website for questions:https://simpeg.discourse.group/a youtube channel where meeting recordings are posted:GeoSci.xyza slack group for real-time chat with users and developers of SimPEG:http://slack.simpeg.xyz/Installinggeoanais on conda-forgecondainstall-cconda-forgegeoanageoanais available onpypiand can be installed by opening a command window and running:pip install geoanaTo install from source, you cangit clone https://github.com/simpeg/geoana.git
python setup.py installLicensegeoana is licensed under theMIT license.
Package: geoAnalytics
geoAnalyticsInstallation using Anaconda.Install and set up Anaconda. URL:https://linuxize.com/post/how-to-install-anaconda-on-centos-7Create a virtual environment using conda. E.g., coda create --name geoAnalyticsEnter into virtual environment.  E.g., conda activate geoAnalyticsInstall python.   E.g., conda install pythonInstall pycharm from the websiteOpen Pycharm and using VCS download the latest copy of geoAnalytics from GitHubIn the pycharm, add geoAnalytics as the interpreterOpen the terminal in pycharm, and execute the following commandpip install mplcursors matplotlib sklearn pandas
Package: geoapify4us
Geoapify4usThis is therepository to help using Geoapify website APIs to make maps or geojson files.NoteThis is the personal trial to publisthe first python package on PyPi.
You can send me such email or message to let me know the problem or advice to improve this package.How to use?Firstly, you need to get your own API key from 'Geoapify.com'
And please check the needed variables before you use this.
The variables for each method are as follows:single_isoline(lat, lon, cal_type, cal_mode, search_range, apiKey, filename)The variables are lattitude, longitude, type of calculation, moving mode, range of isoline map, APIkey, outputfilename.ex) single_isoline(lat = 37.3, lon = 127.1, cal_type = 'distance', cal_mode = 'walk', search_range = 30, apiKey = 'YOUR_API_KEY', filename = 'output')multi_isoline(lat, lon, cal_type, cal_mode, search_range, apiKey, filename)The variables are lattitude, longitude, type of calculation, moving mode, multiple ranges of isoline map, APIkey, outputfilename.ex) multi_isoline(lat = 37.3, lon = 127.1, cal_type = 'distance', cal_mode = 'walk', search_range = '5, 10, 15', apiKey = 'YOUR_API_KEY', filename = 'output')NoteIt can be modified after the package update.
Package: geoapis
geoapisgeoapisis a Python package for simply downloading publicly available web-hosted geo-spatial data. It currently supports downloading LiDAR data from OpenTopography, and vector data from the LINZ Data Service.Installationgeoapisis avaliable onconda-forgeandPyPI. Conda is recommended due to difficulties installing geopandas (a dependency) with pip on Windows. See theWiki Install Instructionsfor more information.DocumentationPackage API documentation is hosted athttps://rosepearson.github.io/GeoFabrics/. Usage, installation and testing documentation can be found at theGitHub Wiki.DevelopmentPlease see theissuesfor details on coming features and additions to the software. Please also submit any requests for new functionality here.ContributionsThere is no current expectations of contributions to this project. We accept input in code reviews now. If you would like to be involved in the project, please contact the maintainer.ContactsMaintainer: Rose Pearson @rosepearsonrose.pearson@niwa.co.nzLicenseMIT